
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;

namespace Mud.EmlenMudMain
{
#if NO_SILVERLIGHT
    [Serializable]
#endif
    public class ItemArmor : IItemArmor, IObject
    {
        public ItemArmor() { }
        private int warmth;		/* v9 */

        public int Warmth
        {
            get { return warmth; }
            set { warmth = value; }
        }
        private int protects_legs;	/* v0 */

        public int Protects_legs
        {
            get { return protects_legs; }
            set { protects_legs = value; }
        }
        private int protects_body;	/* v1 */

        public int Protects_body
        {
            get { return protects_body; }
            set { protects_body = value; }
        }
        private int protects_head;	/* v2 */

        public int Protects_head
        {
            get { return protects_head; }
            set { protects_head = value; }
        }
        private int protects_arms;	/* v3 */

        public int Protects_arms
        {
            get { return protects_arms; }
            set { protects_arms = value; }
        }
        private int pound_rating;	/* v4 */

        public int Pound_rating
        {
            get { return pound_rating; }
            set { pound_rating = value; }
        }
        private int slash_rating;	/* v5 */

        public int Slash_rating
        {
            get { return slash_rating; }
            set { slash_rating = value; }
        }
        private int pierce_rating;	/* v8 */

        public int Pierce_rating
        {
            get { return pierce_rating; }
            set { pierce_rating = value; }
        }
        private int max_condition;	/* v6 */

        public int Max_condition
        {
            get { return max_condition; }
            set { max_condition = value; }
        }
        private int condition_now;	/* v7 */

        public int Condition_now
        {
            get { return condition_now; }
            set { condition_now = value; }
        }

    }
#if NO_SILVERLIGHT
    [Serializable]
#endif
    public class ItemWeapon : IItemWeapon, IObject
    {
        public ItemWeapon() { }

        public int RollDice()
        {
            // TODO: HEREHERE
            return 1;
        }
        private int firstdice;	/* v7 */

        public int Firstdice
        {
            get { return firstdice; }
            set { firstdice = value; }
        }
        private int seconddice;	/* v8 */

        public int Seconddice
        {
            get { return seconddice; }
            set { seconddice = value; }
        }
        private int attack_type;	/* v3 */

        public int Attack_type
        {
            get { return attack_type; }
            set { attack_type = value; }
        }
        private int damage_p;	/* v0 */

        public int Damage_p
        {
            get { return damage_p; }
            set { damage_p = value; }
        }
        private int strength;	/* v1 */

        public int Strength
        {
            get { return strength; }
            set { strength = value; }
        }
    }
#if NO_SILVERLIGHT
    [Serializable]
#endif
    public class ItemDrinkContainer : IItemDrinkContainer, IObject
    {
        public ItemDrinkContainer() { }
        private int max_liquid;	/* v1 */

        public int Max_liquid
        {
            get { return max_liquid; }
            set { max_liquid = value; }
        }
        private int liquid_now;	/* v0 */

        public int Liquid_now
        {
            get { return liquid_now; }
            set { liquid_now = value; }
        }
        private int liquid_type;	/* v2 */

        public int Liquid_type
        {
            get { return liquid_type; }
            set { liquid_type = value; }
        }
        private int not_poison;	/* v3 */

        public int Not_poison
        {
            get { return not_poison; }
            set { not_poison = value; }
        }
    }
    public interface IObject
    {
    }
#if NO_SILVERLIGHT
    [Serializable]
#endif
    public class ItemLight : IItemLight, IObject
    {
        public ItemLight() { }
        private int light_lit;	/* v3 */

        public int Light_lit
        {
            get { return light_lit; }
            set { light_lit = value; }
        }
        private int light_now;	/* v0 */

        public int Light_now
        {
            get { return light_now; }
            set { light_now = value; }
        }
        private int max_light;	/* v1 */

        public int Max_light
        {
            get { return max_light; }
            set { max_light = value; }
        }
        private int light_fillable;	/* v2 */

        public int Light_fillable
        {
            get { return light_fillable; }
            set { light_fillable = value; }
        }

        public bool IsLit() { return (light_now > 0 && light_lit > 0); }
    }
#if NO_SILVERLIGHT
    [Serializable]
#endif
    public class ItemTool : IItemTool, IObject
    {
        public ItemTool() { }
        private int tool_type;	/* v0 */

        public int Tool_type
        {
            get { return tool_type; }
            set { tool_type = value; }
        }
        private int uses;		/* v1 */

        public int Uses
        {
            get { return uses; }
            set { uses = value; }
        }
        private int max_uses;	/* v2 */

        public int Max_uses
        {
            get { return max_uses; }
            set { max_uses = value; }
        }
    }

#if NO_SILVERLIGHT
    [Serializable]
#endif
    public class ItemVehicle : IItemVehicle, IObject
    {
        public ItemVehicle() { }
        private int sector_use;	/* v0 */

        public int Sector_use
        {
            get { return sector_use; }
            set { sector_use = value; }
        }
    }

#if NO_SILVERLIGHT
    [Serializable]
#endif
    public class ItemFountain : IItemFountain, IObject
    {
        public ItemFountain() { }
        private int liquid;	/* v0 */

        public int Liquid
        {
            get { return liquid; }
            set { liquid = value; }
        }
        private int[] spells = new int[3];	/* v1. */

        public int[] Spells
        {
            get { return spells; }
            set { spells = value; }
        }
    }

#if NO_SILVERLIGHT
    [Serializable]
#endif
    public class ItemPotion : IItemPotion, IObject
    {
        public ItemPotion() { }
        private int spell_level;	/* v0 */

        public int Spell_level
        {
            get { return spell_level; }
            set { spell_level = value; }
        }
        private int[] spells = new int[3];	/* v1. */

        public int[] Spells
        {
            get { return spells; }
            set { spells = value; }
        }
    }

#if NO_SILVERLIGHT
    [Serializable]
#endif
    public class ItemSpray : IItemSpray, IObject
    {
        public ItemSpray() { }
        private int sprays;	/* How many charges left */

        public int Sprays
        {
            get { return sprays; }
            set { sprays = value; }
        }
        private List<long> repels = new List<long>();	/* Repels mobs of these vnums (ints) */

        public List<long> Repels
        {
            get { return repels; }
            set { repels = value; }
        }
    }

#if NO_SILVERLIGHT
    [Serializable]
#endif
    public class ItemFood : IItemFood, IObject
    {
        public ItemFood() { }
        private int hours;		/* v0 */

        public int Hours
        {
            get { return hours; }
            set { hours = value; }
        }
        private int not_poison;	/* v3 */

        public int Not_poison
        {
            get { return not_poison; }
            set { not_poison = value; }
        }
    }

#if NO_SILVERLIGHT
    [Serializable]
#endif
    public class ItemGem : IItemGem, IObject
    {
        public ItemGem() { }
        private int gem_type;	/* v0 */

        public int Gem_type
        {
            get { return gem_type; }
            set { gem_type = value; }
        }
        private int mana_now;	/* v1 */

        public int Mana_now
        {
            get { return mana_now; }
            set { mana_now = value; }
        }
        private int max_mana;	/* v2 */

        public int Max_mana
        {
            get { return max_mana; }
            set { max_mana = value; }
        }
        private int max_level;	/* v3 */

        public int Max_level
        {
            get { return max_level; }
            set { max_level = value; }
        }
    }

#if NO_SILVERLIGHT
    [Serializable]
#endif
    public class ItemWand : IItemWand, IObject
    {
        public ItemWand() { }
        private int spell_level;	/* v0 */

        public int Spell_level
        {
            get { return spell_level; }
            set { spell_level = value; }
        }
        private int max_charges;	/* v1 */

        public int Max_charges
        {
            get { return max_charges; }
            set { max_charges = value; }
        }
        private int current_charges;	/* v2 */

        public int Current_charges
        {
            get { return current_charges; }
            set { current_charges = value; }
        }
        private int[] spells = new int[3];	/* v3. */

        public int[] Spells
        {
            get { return spells; }
            set { spells = value; }
        }
    }

#if NO_SILVERLIGHT
    [Serializable]
#endif
    public class ItemFurniture : IItemFurniture, IObject
    {
        public ItemFurniture() { }
        private int to_room_vnum;		/* v1 */

        public int To_room_vnum
        {
            get { return to_room_vnum; }
            set { to_room_vnum = value; }
        }
        private int strip_possessions;	/* v5 */

        public int Strip_possessions
        {
            get { return strip_possessions; }
            set { strip_possessions = value; }
        }
    }

#if NO_SILVERLIGHT
    [Serializable]
#endif
    public class ItemContainer : IItemContainer, IObject
    {
        public ItemContainer() { }
        private int max_weight;		/* v0 */

        public int Max_weight
        {
            get { return max_weight; }
            set { max_weight = value; }
        }
        private int flags;			/* v1 */

        public int Flags
        {
            get { return flags; }
            set { flags = value; }
        }
        private int key_vnum;		/* v2 */

        public int Key_vnum
        {
            get { return key_vnum; }
            set { key_vnum = value; }
        }
        private int money;			/* v8 */

        public int Money
        {
            get { return money; }
            set { money = value; }
        }
        private string reason_for_death;

        public string Reason_for_death
        {
            get { return reason_for_death; }
            set { reason_for_death = value; }
        }
        private List<long> looted_by = new List<long>();

        public List<long> Looted_by
        {
            get { return looted_by; }
            set { looted_by = value; }
        }

    }
#if NO_SILVERLIGHT
    [Serializable]
#endif
    public class ItemClimbable : IItemClimbable, IObject
    {
        public ItemClimbable() { }
        private int up_down;	/* v0 */

        public int Up_down
        {
            get { return up_down; }
            set { up_down = value; }
        }
        private int above;			/* v2 */

        public int Above
        {
            get { return above; }
            set { above = value; }
        }
        private int below;			/* v3 */

        public int Below
        {
            get { return below; }
            set { below = value; }
        }

    }
#if NO_SILVERLIGHT
    [Serializable]
#endif
    public class ItemBook : IItemBook, IObject
    {
        public ItemBook() { }
        private int teaches;	/* v0 */

        public int Teaches
        {
            get { return teaches; }
            set { teaches = value; }
        }
    }

#if NO_SILVERLIGHT
    [Serializable]
#endif
    public class ItemBlood : IItemBlood, IObject
    {



        public ItemBlood() { }
        private int door;			/* v0 */

        public int Door
        {
            get { return door; }
            set { door = value; }
        }
    }
}

// OLD CODE to PORT: ugh!!!


//void do_drag (CharacterData  chr, string szUserArguments)
//{
//  char arg1[STD_LENGTH];
//  char buf[STD_LENGTH];
//  SINGLE_OBJECT *obj;
//  CharacterData rch;
//  char arg2[STD_LENGTH];
//  int moveDirection;
//  ROOM_DATA *oldroom;
//  DEFINE_COMMAND ("drag", do_drag, POSITION_STANDING, 0, NORMAL, "This command allows you to drag a corpse.")

//    arg1[0] = '\0';
//  arg2[0] = '\0';
//  if (strlen (szUserArguments) >= 50)
//    return;
//  szUserArguments = one_argy (szUserArguments, arg1);
//  szUserArguments = one_argy (szUserArguments, arg2);
//  if (arg1[0] == '\0')
//    {
//      send_to_char ("Drag what?\n\r", chr);
//      return;
//    }
//  if (arg2[0] == '\0')
//    {
//      send_to_char ("In which direction?\n\r", chr);
//      return;
//    }
//  if ((obj = get_obj_here (chr, arg1, SEARCH_ROOM_FIRST)) == NULL || obj->carried_by != NULL || obj->GetInRoom() == NULL)
//    {
//      send_to_char ("I don't see that object here....\n\r", chr);
//      return;
//    }
//  if (obj->pIndexData->item_type != ITEM_CORPSE_PC && obj->pIndexData->item_type != ITEM_CORPSE_NPC &&
//      !CAN_WEAR (obj, ITEM_TAKE))
//    {
//      send_to_char ("You can't drag that object...\n\r", chr);
//      return;
//    }
//  if (chr->MPCurrent < 10)
//    {
//      send_to_char ("You are too exhausted to drag anything...\n\r", chr);
//      return;
//    }
//  moveDirection = -1;
//  if (arg2[0] == 'n' || arg2[0] == 'N')
//    moveDirection = DIR_NORTH;
//  if (arg2[0] == 'w' || arg2[0] == 'W')
//    moveDirection = DIR_WEST;
//  if (arg2[0] == 'e' || arg2[0] == 'E')
//    moveDirection = DIR_EAST;
//  if (arg2[0] == 's' || arg2[0] == 'S')
//    moveDirection = DIR_SOUTH;
//  if (arg2[0] == 'u' || arg2[0] == 'U')
//    moveDirection = DIR_UP;
//  if (arg2[0] == 'd' || arg2[0] == 'D')
//    moveDirection = DIR_DOWN;
//  if (moveDirection == -1)
//    {
//      send_to_char ("Which direction?\n\r", chr);
//      return;
//    }
//  oldroom = chr->inRoom;
//  if (!move_char (chr, moveDirection))
//    {
//      send_to_char ("How can you drag something to someplace you can't even go!\n\r", chr);
//      return;
//    }
//  sprintf (buf, "%s drags %s %s.\n\r", NAME (chr),
//       (obj->short_descr ? obj->short_descr : obj->pIndexData->short_descr),
//      dir_name[moveDirection]);
//  if (oldroom->MoreRoomInfo)
//    for (rch = oldroom->MoreRoomInfo->people; rch != NULL; rch = rch->next_in_room)
//      {
//   if (rch == chr)
//     continue;
//   if (!IS_AWAKE (rch))
//     continue;
//   send_to_char (buf, rch);
//      }
//  obj_from (obj);
//  obj_to_room (obj, chr->inRoom);
//  sprintf (buf, "You drag %s into the currentRoom.\n\r",
//      (obj->short_descr ? obj->short_descr : obj->pIndexData->short_descr));
//  send_to_char (buf, chr);
//  sprintf (buf, "%s drags %s in from %s.\n\r", NAME (chr),
//       (obj->short_descr ? obj->short_descr : obj->pIndexData->short_descr),
//      dir_rev[rev_dir[moveDirection]]);
//  for (rch = chr->inRoom->MoreRoomInfo->people; rch != NULL; rch = rch->next_in_room)
//    {
//      if (rch == chr)
//   continue;
//      if (!IS_AWAKE (rch))
//   continue;
//      send_to_char (buf, rch);
//    }
//  SUBMOVE(chr, number_range (8, 10));
//  return;
//}

//void do_meditate (CharacterData  chr, string szUserArguments)
//{
//  DEFINE_COMMAND ("meditate", do_meditate, POSITION_RESTING, 0, NORMAL, "Allows you to meditate, and focus on magical energy regeneration.")

//    if (RIDING (chr) != NULL)
//    {
//      send_to_char ("If you wanted to sit and meditate, you would not be chRiding!\n\r", chr);
//      return;
//    }
//  if (chr->fightInfoInternal && chr->fightInfoInternal->ears > 9)
//    {
//      send_to_char ("You are bashed; you can't meditate...\n\r", chr);
//      return;
//    }
//if (FIGHTING(chr)) {
//      currentActionsAndBehavior ("You must start meditation from a standing or resting position.", chr, NULL, NULL, TO_CHAR);
//   return;
//   }
//  if (chr->position != POSITION_STANDING && chr->position != POSITION_RESTING && chr->position != POSITION_MEDITATING)
//    {
//      currentActionsAndBehavior ("You must start meditation from a standing or resting position.", chr, NULL, NULL, TO_CHAR);
//      return;
//    }
//  if (chr->position == POSITION_MEDITATING)
//    {
//      NEW_POSITION(chr, POSITION_STANDING);
//      currentActionsAndBehavior ("You stop meditating, and clamber to your feet.", chr, NULL, NULL, TO_CHAR);
//      currentActionsAndBehavior ("$N stops meditating, and clambers to $s feet.", chr, NULL, chr, TO_ROOM);
//      return;
//    }
//  NEW_POSITION(chr, POSITION_MEDITATING);
//  currentActionsAndBehavior ("You sit down cross-legged and begin meditating.", chr, NULL, NULL, TO_CHAR);
//  currentActionsAndBehavior ("$N sits down, clears $s mind, and begins meditating.", chr, NULL, chr, TO_ROOM);
//  return;
//}

//void get_obj (CharacterData  chr, SINGLE_OBJECT * obj, SINGLE_OBJECT * container)
//{
//  CharacterData fch;
//  CharacterData fch_next;
//#ifndef NEW_WORLD
//  if (obj->pIndexData->item_type == ITEM_BOAT && !is_boat_empty (obj))
//    {
//      send_to_char ("The boat has people inside! It's just too heavy to carry...\n\r", chr);
//      return;
//    }
//#endif
//  if (!CAN_WEAR (obj, ITEM_TAKE))
//    {
//      send_to_char ("You can't take that.\n\r", chr);
//      return;
//    }

//  for (fch = chr->inRoom->MoreRoomInfo->people; fch != NULL; fch = fch_next)
//    {
//      fch_next = fch->next_in_room;
//      if (IS_MOB (fch) && IS_SET (fch->pIndexData->act3, ACT3_GUARD_ITEM)
//     && obj->pIndexData->vnumClan == fch->pIndexData->mobGuards)
//   {
//     do_say (fch, "Don't touch that!");
//     multi_hit (fch, chr, TYPE_UNDEFINED);
//   }
//    }
//  if (container != NULL)
//    {
//      currentActionsAndBehavior ("You get $p\x1B[37;0m from $P\x1B[0m.", chr, obj, container, TO_CHAR);
//      currentActionsAndBehavior ("$n gets $p\x1B[37;0m from $P\x1B[0m.", chr, obj, container, TO_ROOM);
//    }
//  else
//    {
//      currentActionsAndBehavior ("You get $p\x1B[37;0m.", chr, obj, container, TO_CHAR);
//      currentActionsAndBehavior ("$n gets $p\x1B[37;0m.", chr, obj, container, TO_ROOM);
//    }
//  obj_from (obj);
//  obj->wear_loc = -1;
//  obj_to_char (obj, chr);
//  return;
//}

//void do_take (CharacterData  chr, string szUserArguments)
//{
//  DEFINE_COMMAND ("take", do_get, POSITION_RESTING, 0, NORMAL, "This command allows you to get an object from an object, or from the ground, or to 'take control' of a boat.")
//    return;
//}

//void do_get (CharacterData  chr, string szUserArguments)
//{
//  char arg1[SML_LENGTH];
//  char arg2[SML_LENGTH];
//  char buffy[SML_LENGTH];
//  SINGLE_OBJECT *obj;
//  SINGLE_OBJECT *obj_next;
//  SINGLE_OBJECT *container;
//  I_CONTAINER *cnt;
//  bool found = FALSE;
//  bool gonnasave;


//  DEFINE_COMMAND ("get", do_get, POSITION_RESTING, 0, NORMAL, "This command allows you to get an object from an object, or from the ground.")
//    check_room_more (chr->inRoom);
//  gonnasave = FALSE;
//#ifndef NEW_WORLD
//  if (chr->ced && chr->ced->in_boat != NULL && chr->ced->in_boat->boat && !str_cmp (szUserArguments, "control"))
//    {
//      char buffr[STD_LENGTH];
//      if (!chr->ced->in_boat->boat || chr->ced->in_boat->boat->navigator == chr)
//   {
//     send_to_char ("You are already the navigator of the vessel!\n\r", chr);
//     return;
//   }
//      if (!IS_EVIL (chr) && chr->ced->in_boat->boat->navigator != NULL && IS_EVIL (chr->ced->in_boat->boat->navigator))
//   {
//     send_to_char ("You'll have to kill the current navigator first...\n\r", chr);
//     return;
//   }
//      if (IS_EVIL (chr) && chr->ced->in_boat->boat->navigator != NULL && !IS_EVIL (chr->ced->in_boat->boat->navigator))
//   {
//     send_to_char ("You'll have to kill the current navigator first...\n\r", chr);
//     return;
//   }
//      if (chr->ced->in_boat->boat->navigator == NULL)
//   {
//     send_to_char ("You take the helm of the vessel...\n\r", chr);
//     sprintf (buffr, "[%s takes control of the boat's navigation]\n\r", NAME (chr));
//     send_to_boat (chr, chr->ced->in_boat, buffr);
//   }
//      else
//   {
//     send_to_char ("You take the helm of the vessel...\n\r", chr);
//     sprintf (buffr, "[%s takes a breather as %s steps up to the vessel's helm]\n\r", NAME (chr->ced->in_boat->boat->navigator), NAME (chr));
//     send_to_boat (chr, chr->ced->in_boat, buffr);
//   }
//      chr->ced->in_boat->boat->navigator = chr;
//      return;
//    }
//#endif
//  if (!str_prefix ("cont", szUserArguments) && IS_SET (chr->inRoom->rmflags, ROOM_ISVEHICLE) && chr->inRoom->MoreRoomInfo && chr->inRoom->MoreRoomInfo->linkedTo)
//    {
//      char buffr[STD_LENGTH];
//      ROOM_DATA *rs;
//      sprintf (buffr, "You take control of %s...\n\r", chr->inRoom->name);
//      send_to_char (buffr, chr);
//      sprintf (buffr, "%s takes control of the vehicle's navigation.", NAME (chr));
//      currentActionsAndBehavior (buffr, chr, NULL, chr, TO_ROOM);
//      rs = chr->inRoom;
//      char_from_room (chr);
//      char_to_room (chr, rs);
//      return;
//    }

//  if (!str_cmp (szUserArguments, "all corpse"))
//    {
//      szUserArguments = one_argy (szUserArguments, arg1);
//      szUserArguments = one_argy (szUserArguments, arg2);
//    }
//  else
//    {
//      szUserArguments = one_argy (szUserArguments, arg1);
//      while (str_prefix ("from", szUserArguments) && szUserArguments != "" && szUserArguments[0] != '\0')
//   szUserArguments = one_argy (szUserArguments, arg1);
//      szUserArguments = one_argy (szUserArguments, arg2);
//      while (szUserArguments != "" && szUserArguments[0] != '\0')
//   szUserArguments = one_argy (szUserArguments, arg2);
//    }

//  if (arg1[0] == '\0')
//    {
//      send_to_char ("Get what?\n\r", chr);
//      return;
//    }
//  if (arg2[0] == '\0')
//    {
//      if (str_cmp (arg1, "all") && str_prefix ("all.", arg1))
//   {
//     if (!str_cmp (arg1, "coins") || !str_cmp (arg1, "coin"))
//       {
//         if (chr->inRoom->MoreRoomInfo->copper < 1 && chr->inRoom->MoreRoomInfo->gold < 1)
//      {
//        send_to_char ("I see no coins here.\n\r", chr);
//        return;
//      }
//         bah[0] = '\0';
//         if (chr->inRoom->MoreRoomInfo->gold == 0 && chr->inRoom->MoreRoomInfo->copper > 0)
//      sprintf (bah, "You get %d \x1B[33;0mcopper\x1B[37m coin%s.\n\r",
//          chr->inRoom->MoreRoomInfo->copper, (chr->inRoom->MoreRoomInfo->copper > 1 ? "s" : ""));
//         else if (chr->inRoom->MoreRoomInfo->gold > 0 && chr->inRoom->MoreRoomInfo->copper == 0)
//      sprintf (bah, "You get %d \x1B[33;1mgold\x1B[37;0m coin%s.\n\r",
//          chr->inRoom->MoreRoomInfo->gold, (chr->inRoom->MoreRoomInfo->gold > 1 ? "s" : ""));
//         else if (chr->inRoom->MoreRoomInfo->gold > 0 && chr->inRoom->MoreRoomInfo->copper > 0)
//      sprintf (bah, "You get %d \x1B[33;0mcopper\x1B[37m coin%s and %d \x1B[33;1mgold\x1B[37;0m coin%s.\n\r",
//          chr->inRoom->MoreRoomInfo->copper, (chr->inRoom->MoreRoomInfo->copper > 1 ? "s" : ""),
//          chr->inRoom->MoreRoomInfo->gold, (chr->inRoom->MoreRoomInfo->gold > 1 ? "s" : ""));
//         send_to_char (bah, chr);
//         chr->copper += chr->inRoom->MoreRoomInfo->copper;
//         chr->inRoom->MoreRoomInfo->copper = 0;
//         chr->gold += chr->inRoom->MoreRoomInfo->gold;
//         chr->inRoom->MoreRoomInfo->gold = 0;
//         return;
//       }
//     obj = get_obj_list (chr, arg1, chr->inRoom->MoreRoomInfo->contents);
//     if (obj == NULL || IS_SET (obj->extra_flags, ITEM_UNSEEN))
//       {
//         currentActionsAndBehavior ("I don't see that here.", chr, NULL, NULL, TO_CHAR);
//         return;
//       }
//     get_obj (chr, obj, NULL);
//   }
//      else
//   {
//     found = FALSE;
//     if (chr->inRoom->MoreRoomInfo->gold == 0 && chr->inRoom->MoreRoomInfo->copper > 0)
//       sprintf (bah, "You get %d \x1B[33;0mcopper\x1B[37m coin%s.\n\r",
//           chr->inRoom->MoreRoomInfo->copper, (chr->inRoom->MoreRoomInfo->copper > 1 ? "s" : ""));
//     else if (chr->inRoom->MoreRoomInfo->gold > 0 && chr->inRoom->MoreRoomInfo->copper == 0)
//       sprintf (bah, "You get %d \x1B[33;1mgold\x1B[37;0m coin%s.\n\r",
//           chr->inRoom->MoreRoomInfo->gold, (chr->inRoom->MoreRoomInfo->gold > 1 ? "s" : ""));
//     else if (chr->inRoom->MoreRoomInfo->gold > 0 && chr->inRoom->MoreRoomInfo->copper > 0)
//       sprintf (bah, "You get %d \x1B[33;0mcopper\x1B[37m coin%s and %d \x1B[33;1mgold\x1B[37;0m coin%s.\n\r",
//           chr->inRoom->MoreRoomInfo->copper, (chr->inRoom->MoreRoomInfo->copper > 1 ? "s" : ""),
//           chr->inRoom->MoreRoomInfo->gold, (chr->inRoom->MoreRoomInfo->gold > 1 ? "s" : ""));
//     if (chr->inRoom->MoreRoomInfo->gold > 0 || chr->inRoom->MoreRoomInfo->copper > 0)
//       send_to_char (bah, chr);
//     chr->copper += chr->inRoom->MoreRoomInfo->copper;
//     chr->inRoom->MoreRoomInfo->copper = 0;
//     chr->gold += chr->inRoom->MoreRoomInfo->gold;
//     chr->inRoom->MoreRoomInfo->gold = 0;
//     found = TRUE;
//     for (obj = chr->inRoom->MoreRoomInfo->contents; obj != NULL; obj = obj_next)
//       {
//         obj_next = obj->next_content;
//         if ((arg1[3] == '\0' || is_name (&arg1[4], obj->pIndexData->name))
//        && can_see_obj (chr, obj) && !IS_SET (obj->extra_flags, ITEM_UNSEEN))
//      {
//        found = TRUE;
//        get_obj (chr, obj, NULL);
//      }
//       }
//     if (!found)
//       {
//         if (arg1[3] == '\0')
//      send_to_char ("I see nothing here.\n\r", chr);
//         else
//      currentActionsAndBehavior ("I don't see that here.", chr, NULL, NULL, TO_CHAR);
//       }
//   }
//    }
//  else
//    {
//      if (!str_cmp (arg2, "all") || !str_prefix ("all.", arg2))
//   {
//     send_to_char ("You can't do that.\n\r", chr);
//     return;
//   }
//      if ((container = (!str_prefix ("cor", arg2) ? get_obj_here (chr, arg2, SEARCH_ROOM_FIRST) : get_obj_here (chr, arg2, SEARCH_INV_FIRST))) == NULL)
//   {
//     currentActionsAndBehavior ("I don't see that here.", chr, NULL, NULL, TO_CHAR);
//     return;
//   }
//      switch (container->pIndexData->item_type)
//   {
//   default:
//     send_to_char ("You can't look inside that...\n\r", chr);
//     return;
//   case ITEM_CONTAINER:
//   case ITEM_CORPSE_NPC:
//     {
//       cnt = (I_CONTAINER *) container->MoreRoomInfo;
//       if ((cnt->money > 0 || container->contains) && strlen (NAME (chr)) < 30)
//         {
//      if (cnt->looted_by[0] == '\0')
//        {
//          strcpy (cnt->looted_by, NAME (chr));
//        }
//      else if (cnt->looted_by_two[0] == '\0' && str_cmp (NAME (chr), cnt->looted_by))
//        {
//          strcpy (cnt->looted_by_two, NAME (chr));
//        }
//         }
//     }
//     break;
//   case ITEM_CORPSE_PC:
//     {
//       char name[SML_LENGTH];
//       string pd;
//       if (!pow.getFromCorpseWhileInCombat && FIGHTING (chr))
//         {
//      send_to_char ("You don't have time to loot the corpse while you are chAttacking!\n\r", chr);
//      return;
//         }
//       cnt = (I_CONTAINER *) container->MoreRoomInfo;
//       pd = OOSTR (container, short_descr);
//       pd = one_argy (pd, name);
//       pd = one_argy (pd, name);
//       pd = one_argy (pd, name);
//       pd = one_argy (pd, name);
//       /*name now equals the name of the person */
//       if (IS_PLAYER(chr) && LEVEL(chr)<=pow.lootLevel && str_cmp(name,NAME(chr))) {
//      send_to_char("You cannot loot another person's corpse at that low level.\n\r",chr);
//      return;
//      }
//       if ((container->contains || cnt->money > 0) && str_cmp (NAME (chr), capitalize (name)))
//         {
//      if (strlen (NAME (chr)) < 30)
//        {
//          if (cnt->looted_by[0] == '\0')
//            {
//         strcpy (cnt->looted_by, NAME (chr));
//            }
//          else if (cnt->looted_by_two[0] == '\0' && str_cmp (NAME (chr), cnt->looted_by))
//            {
//         strcpy (cnt->looted_by_two, NAME (chr));
//            }
//        }
//      fprintf (stderr, "%s just tooks something from %s's corpse.\n",
//          NAME (chr), capitalize (name));
//         }
//       if (container->contains || cnt->money > 0)
//         {
//      sprintf (buffy, "%s%s.cor", PLAYER_DIR_2, capitalize (name));
//      unlink (buffy);
//         }
//       gonnasave = TRUE;
//       if (IS_PLAYER (chr) && str_cmp (NAME (chr), capitalize (name)))
//         {
//      chr->pcdata->no_quit_pk = 5;
//         }
//     }
//   }
//      cnt = (I_CONTAINER *) container->MoreRoomInfo;
//      if (IS_SET (cnt->flags, CONT_CLOSED))
//   {
//     currentActionsAndBehavior ("The $d is closed.", chr, NULL, container->pIndexData->name, TO_CHAR);
//     return;
//   }
//      if (str_cmp (arg1, "all") && str_prefix ("all.", arg1))
//   {
//     cnt = (I_CONTAINER *) container->MoreRoomInfo;
//     if (!str_cmp (arg1, "coins"))
//       {
//         if (cnt->money < 1)
//      {
//        send_to_char ("I see no coins in there.\n\r", chr);
//        return;
//      }
//         sprintf (bah, "You get %d copper from %s\x1B[37;0m.\n\r", cnt->money, OOSTR (container, short_descr));
//         chr->copper += cnt->money;
//         cnt->money = 0;
//         send_to_char (bah, chr);
//         return;
//       }
//     obj = get_obj_list (chr, arg1, container->contains);
//     if (obj == NULL)
//       {
//         currentActionsAndBehavior ("I see nothing like that in the $T\x1B[0m.", chr, NULL, arg2, TO_CHAR);
//         return;
//       }
//     get_obj (chr, obj, container);
//   }
//      else
//   {
//     cnt = (I_CONTAINER *) container->MoreRoomInfo;
//     found = FALSE;
//     if (cnt->money > 0)
//       {
//         sprintf (bah, "You get %s from %s.\x1B[37;0m\n\r", name_amount (cnt->money), OOSTR (container, short_descr));
//         chr->copper += cnt->money;
//         cnt->money = 0;
//         send_to_char (bah, chr);
//         found = TRUE;
//       }
//     for (obj = container->contains; obj != NULL; obj = obj_next)
//       {
//         obj_next = obj->next_content;
//         if ((arg1[3] == '\0' || is_name (&arg1[4], obj->pIndexData->name))
//        && can_see_obj (chr, obj))
//      {
//        found = TRUE;
//        get_obj (chr, obj, container);
//      }
//       }
//     if (!found)
//       {
//         if (arg1[3] == '\0')
//      currentActionsAndBehavior ("I see nothing in $T\x1B[0m.", chr, NULL, arg2, TO_CHAR);
//         else
//      currentActionsAndBehavior ("I see nothing like that in $T\x1B[0m.", chr, NULL, arg2, TO_CHAR);
//       }
//   }
//    }
///*if (IS_PLAYER(chr) && gonnasave) save_char_obj(chr); */
//  if (IS_PLAYER (chr))
//    update_weight_num (chr);
//  check_clear_more (chr->inRoom);
//  return;
//}

//void do_put (CharacterData  chr, string szUserArguments)
//{
//  char arg1[SML_LENGTH];
//  char arg2[SML_LENGTH];
//  SINGLE_OBJECT *container;
//  SINGLE_OBJECT *obj;
//  SINGLE_OBJECT *obj_next;
//  I_CONTAINER *cnt;
//  DEFINE_COMMAND ("put", do_put, POSITION_RESTING, 0, NORMAL, "This command allows you to put an object in something.")

//    szUserArguments = one_argy (szUserArguments, arg1);
//  while (str_prefix ("in", szUserArguments) && szUserArguments != "" && szUserArguments[0] != '\0')
//    szUserArguments = one_argy (szUserArguments, arg1);
//  szUserArguments = one_argy (szUserArguments, arg2);
//  while (szUserArguments != "" && szUserArguments[0] != '\0')
//    szUserArguments = one_argy (szUserArguments, arg2);

//  if (arg1[0] == '\0' || arg2[0] == '\0')
//    {
//      send_to_char ("Put what in what?\n\r", chr);
//      return;
//    }
//  if (!str_cmp (arg1, "all.coin") || !str_cmp (arg1, "coin") || !str_cmp (arg1, "all.coins") || !str_cmp (arg1, "coins"))
//    {
//      char buffu[STD_LENGTH];
//      if ((container = get_obj_here (chr, arg2, SEARCH_INV_FIRST)) == NULL)
//   {
//     currentActionsAndBehavior ("I see no $T here.", chr, NULL, arg2, TO_CHAR);
//     return;
//   }
//      if (container->pIndexData->item_type != ITEM_CONTAINER)
//   {
//     send_to_char ("You can't put anything inside of that.\n\r", chr);
//     return;
//   }
//      cnt = (I_CONTAINER *) container->MoreRoomInfo;
//      cnt->money += chr->copper;
//      sprintf (buffu, "You put your copper in %s.  (GoldCoins pieces can't go inside containers).\n\r", OOSTR (container, short_descr));
//      currentActionsAndBehavior (buffu, chr, NULL, chr, TO_CHAR);
//      chr->copper = 0;
//      return;
//    }
//  if (!str_cmp (arg2, "all") || !str_prefix ("all.", arg2))
//    {
//      send_to_char ("You can't do that.\n\r", chr);
//      return;
//    }
//  if ((container = get_obj_here (chr, arg2, SEARCH_INV_FIRST)) == NULL)
//    {
//      currentActionsAndBehavior ("I see no $T here.", chr, NULL, arg2, TO_CHAR);
//      return;
//    }
//  if (container->pIndexData->item_type != ITEM_CONTAINER)
//    {
//      send_to_char ("That's not a container.\n\r", chr);
//      return;
//    }


// cnt = (I_CONTAINER *) container->MoreRoomInfo;
//  if (IS_SET (cnt->flags, CONT_CLOSED))
//    {
//      currentActionsAndBehavior ("The $d is closed.", chr, NULL, container->pIndexData->name, TO_CHAR);
//      return;
//    }
//  if (str_cmp (arg1, "all") && str_prefix ("all.", arg1))
//    {
//      if ((obj = get_obj_inv (chr, arg1)) == NULL)
//   {
//     send_to_char ("You do not have that item.\n\r", chr);
//     return;
//   }
//if (obj->pIndexData->vnumClan<MAX_LIMITED && obj->pIndexData->how_many>0) {
//   send_to_char("This item doesn't seem to fit inside the container.\n\r",chr);
//   return;
//   }
//  if (obj->wear_loc!=WEAR_NONE && IS_SET (obj->extra_flags, ITEM_NOREMOVE)) {
//   send_to_char("You can't remove that item!\n\r",chr);
//   return;
//   }
//      if (obj == container)
//   {
//     send_to_char ("Now that would be a trick, eh?\n\r", chr);
//     return;
//   }
//      if (!can_drop_obj (chr, obj))
//   {
//     send_to_char ("You can't let go of it.\n\r", chr);
//     return;
//   }
//      if ((cnt->max_weight + container->pIndexData->weight)
//     < (get_obj_weight (obj) + get_obj_weight (container)))
//   {
//     send_to_char ("It won't fit.\n\r", chr);
//     return;
//   }
//      obj_from (obj);
//      obj_to_obj (obj, container);
//      currentActionsAndBehavior ("$n puts $p\x1B[0m in $P\x1B[0m.", chr, obj, container, TO_ROOM);
//      currentActionsAndBehavior ("You put $p\x1B[0m in $P\x1B[0m.", chr, obj, container, TO_CHAR);
//    }
//  else
//    {
//      cnt = (I_CONTAINER *) container->MoreRoomInfo;
//      for (obj = chr->carryingObjects; obj != NULL; obj = obj_next)
//   {
//     obj_next = obj->next_content;
//if (obj->pIndexData->vnumClan<MAX_LIMITED && obj->pIndexData->how_many>0) continue;
//     if ((arg1[3] == '\0' || is_name (&arg1[4], obj->pIndexData->name))
//         && can_see_obj (chr, obj)
//         && obj->wear_loc == WEAR_NONE
//         && obj != container
//         && can_drop_obj (chr, obj)
//         && get_obj_weight (obj) + get_obj_weight (container)
//         <= cnt->max_weight)
//       {
//         obj_from (obj);
//         obj_to_obj (obj, container);
//         currentActionsAndBehavior ("$n puts $p\x1B[0m in $P\x1B[0m.", chr, obj, container, TO_ROOM);
//         currentActionsAndBehavior ("You put $p\x1B[0m in $P\x1B[0m.", chr, obj, container, TO_CHAR);
//       }
//   }
//    }
//  return;
//}

//void do_drop (CharacterData  chr, string szUserArguments)
//{
//  char arg[SML_LENGTH];
//  SINGLE_OBJECT *obj;
//  char buf[SML_LENGTH];
//  int amount;
//  SINGLE_OBJECT *obj_next;
//  bool found = FALSE;
//  char arg2[SML_LENGTH];
//  DEFINE_COMMAND ("drop", do_drop, POSITION_RESTING, 0, NORMAL, "This command allows you to drop an object.")

//    szUserArguments = one_argy (szUserArguments, arg);
//  if (!is_number (arg))
//    {
//      while (szUserArguments != "" && szUserArguments[0] != '\0')
//   szUserArguments = one_argy (szUserArguments, arg);
//    }
//  szUserArguments = one_argy (szUserArguments, arg2);

//  CAN_DROP_ITEMS_IN_BGROUND (no)
//    CAN_DROP_ITEMS_IN_ARENA (no)

//    if (arg[0] == '\0')
//    {
//      send_to_char ("Drop what?\n\r", chr);
//      return;
//    }
//  if (!str_cmp (arg, "coin") || !str_cmp (arg, "coins") || !str_cmp (arg, "all.coin") || !str_cmp (arg, "all.coins"))
//    {
//      char bufff[STD_LENGTH];
//      if (tally_coins (chr) < 0)
//   {
//     send_to_char ("You have no coins in your inventory!\n\r", chr);
//     return;
//   }
//      if (LEVEL (chr) < 100 || IS_REAL_GOD (chr))
//   {
//     chr->inRoom->MoreRoomInfo->copper += chr->copper;
//     chr->inRoom->MoreRoomInfo->gold += chr->gold;
//   }
//      sprintf (bufff, "You drop your coins.\n\r");
//      send_to_char (bufff, chr);
//      chr->gold = 0;
//      chr->copper = 0;
//      return;
//    }
//  if (IS_PLAYER (chr))
//    {
//      update_weight_num (chr);
//      /*save_char_obj(chr); */
//    }

//  if ((!str_cmp (arg2, "gold"))
//      && (is_number (arg) && atoi (arg) > 0))
//    {
//      amount = atoi (arg);
//      if (amount < 1)
//   return;
//      if (chr->gold < amount)
//   {
//     send_to_char ("You don't have that many \x1B[33;1mgold\x1B[37;0m coins.\n\r", chr);
//     return;
//   }
//      chr->gold -= amount;
//      if (chr->inRoom->sectortyp != SECT_WATER_SWIM && chr->inRoom->sectortyp != SECT_WATER_NOSWIM &&
//     ((LEVEL (chr) < 100) || IS_REAL_GOD (chr)))
//   chr->inRoom->MoreRoomInfo->gold += amount;
//      sprintf (buf, "You drop %d \x1B[33;1mgold\x1B[37;0m coins.\n\r", amount);
//      send_to_char (buf, chr);
//      currentActionsAndBehavior ("$n drops some \x1B[33;1mgold\x1B[37;0m coins.", chr, NULL, NULL, TO_ROOM);
//      return;
//    }

//  if ((!str_cmp (arg2, "copper"))
//      && (is_number (arg) && atoi (arg) > 0))
//    {
//      amount = atoi (arg);
//      if (amount < 1)
//   return;
//      if (chr->copper < amount)
//   {
//     send_to_char ("You don't have that many \x1B[33mcopper\x1B[37;0m coins.\n\r", chr);
//     return;
//   }
//      chr->copper -= amount;
//      if (chr->inRoom->sectortyp != SECT_WATER_SWIM && chr->inRoom->sectortyp != SECT_WATER_NOSWIM &&
//     ((LEVEL (chr) < 100) || IS_REAL_GOD (chr)))
//   chr->inRoom->MoreRoomInfo->copper += amount;
//      sprintf (buf, "You drop %d \x1B[33mcopper\x1B[37;0m coins.\n\r", amount);
//      send_to_char (buf, chr);
//      currentActionsAndBehavior ("$n drops some \x1B[33mcopper\x1B[37;0m coins.", chr, NULL, NULL, TO_ROOM);
//      return;
//    }
//  if ((str_cmp (arg, "all") && str_prefix ("all.", arg)) || (chr->fightInfoInternal && chr->fightInfoInternal->combat_delay_count == 9))
//    {
//      if ((obj = get_obj_inv (chr, arg)) == NULL)
//   {
//     send_to_char ("You do not have that item.\n\r", chr);
//     return;
//   }
//      else if ((!NOT_WORN (obj))	/*|| (obj->wear_loc==WEAR_HOLD_1) ||
//                  (obj->wear_loc==WEAR_HOLD_2) */ )
//   {
//     send_to_char ("You will have to remove it first.\n\r", chr);
//     return;
//   }
//      if (!can_drop_obj (chr, obj))
//   {
//     send_to_char ("You can't let go of it.\n\r", chr);
//     return;
//   }

//      if (obj->wear_loc == -1 && !IS_SET (obj->extra_flags, ITEM_UNSEEN) &&
//     (chr->fightInfoInternal && chr->fightInfoInternal->combat_delay_count == 9))
//   {
//     currentActionsAndBehavior ("You hide $p\x1B[0m in the currentRoom.", chr, obj, NULL, TO_CHAR);
//     chr->fightInfoInternal->combat_delay_count = 0;
//     obj->extra_flags ^= ITEM_UNSEEN;
//     obj_from (obj);
//     if (chr->inRoom->sectortyp == SECT_WATER_SWIM || chr->inRoom->sectortyp == SECT_WATER_NOSWIM)
//       {
//         currentActionsAndBehavior ("The waters cause $p to sink beneath them; lost forever.", chr, obj, NULL, TO_CHAR);
//         free_it (obj);
//         return;
//       }
//     obj_to_room (obj, chr->inRoom);
//     if (number_percent () > chr->pcdata->learned[gsn_hide] + chr->pcdata->plus_hide)
//       currentActionsAndBehavior ("$n hides $p\x1B[0m.", chr, obj, NULL, TO_ROOM);
//     return;
//   }


//      if (obj->pIndexData->item_type == ITEM_BOAT && obj->boat)
//   {
//     BLIST *bd;
//     bd = new BLIST; //  (sizeof (*bd));
//     bd->next = base_blist;
//     base_blist = bd;
//     bd->vnumClan = chr->inRoom->vnumClan;
//     save_boats ();
//   }
//      currentActionsAndBehavior ("You drop $p\x1B[37;0m.", chr, obj, NULL, TO_CHAR);
//      currentActionsAndBehavior ("$n drops $p\x1B[37;0m.", chr, obj, NULL, TO_ROOM);
//      obj_from (obj);
//      if (obj->pIndexData->item_type != ITEM_BOAT && (chr->inRoom->sectortyp == SECT_WATER_SWIM || chr->inRoom->sectortyp == SECT_WATER_NOSWIM))
//   {
//     currentActionsAndBehavior ("The waters cause $p to sink beneath them; lost forever.", chr, obj, NULL, TO_CHAR);
//     free_it (obj);
//   }
//      else
//   {
//     obj_to_room (obj, chr->inRoom);

//   again_8:
///* Dropped item, check for triggers on object! */
//     {
//       SINGLE_TRIGGER *tr;
//       SCRIPT_INFO *s;
//       for (tr = trigger_list[TDROPPED]; tr != NULL; tr = tr->next)
//         {
//      if (obj->pIndexData->vnumClan == tr->attached_to_obj)
//        {
//          if (tr->running_info && !tr->interrupted)
//            continue;	/* Already running, interrupted, but script says not to allow interruptions. */
//          if (tr->running_info && tr->interrupted != 2)
//            {
//         end_script (tr->running_info);
//         goto again_8;
//            }
//         {
//            char tmp[STD_LENGTH];
//            sprintf(tmp, "%d",chr->inRoom->vnumClan);
//          if (tr->keywords[0] != '\0' && !one_is_in_list_two (tmp, tr->keywords))
//            continue;
//         }
//          /* ----------------- */
//          /* Start the script! */
//          /* ----------------- */
//          tr->running_info = new SCRIPT_INFO; //  (sizeof (*tr->running_info));
//          s = tr->running_info;
//          bzero (s, sizeof (*s));
//          s->current = chr;
//          s->obj = obj;
//          strcpy (s->code_seg, tr->code_label);
//          s->current_line = 0;
//          s->called_by = tr;
//          s->next = info_list;
//          info_list = s;
//          execute_code (s);
//          /* ----------------- */
//        }
//         }
//     }
///* End trigger check! */
//   again_9:
///* Dropped item, check for triggers on currentRoom! */
//     {
//       SINGLE_TRIGGER *tr;
//       SCRIPT_INFO *s;
//       for (tr = trigger_list[TDROPPED]; tr != NULL; tr = tr->next)
//         {
//      if (chr->inRoom->vnumClan == tr->attached_to_room)
//        {
//          if (tr->running_info && !tr->interrupted)
//            continue;	/* Already running, interrupted, but script says not to allow interruptions. */
//          if (tr->running_info && tr->interrupted != 2)
//            {
//         end_script (tr->running_info);
//         goto again_9;
//            }
//         {
//            char tmp[STD_LENGTH];
//            sprintf(tmp, "%d",obj->pIndexData->vnumClan);
//          if (tr->keywords[0] != '\0' && !one_is_in_list_two (tmp, tr->keywords))
//            continue;
//         }
//          /* ----------------- */
//          /* Start the script! */
//          /* ----------------- */
//          tr->running_info = new SCRIPT_INFO; //  (sizeof (*tr->running_info));
//          s = tr->running_info;
//          bzero (s, sizeof (*s));
//          s->current = chr;
//          s->currentRoom = chr->inRoom;
//          s->obj = obj;
//          strcpy (s->code_seg, tr->code_label);
//          s->current_line = 0;
//          s->called_by = tr;
//          s->next = info_list;
//          info_list = s;
//          execute_code (s);
//          /* ----------------- */
//        }
//         }
//     }
///* End trigger check! */





//   }
//    }
//  else
//    {
//      if (!str_cmp (arg, "all"))
//   {
//     found = FALSE;
//     if (tally_coins (chr) > 0)
//       {
//         char bunl[STD_LENGTH];
//         if (chr->inRoom->sectortyp != SECT_WATER_SWIM && chr->inRoom->sectortyp != SECT_WATER_NOSWIM &&
//        (LEVEL (chr) < 100 || IS_REAL_GOD (chr)))
//      {
//        chr->inRoom->MoreRoomInfo->gold += chr->gold;
//        chr->inRoom->MoreRoomInfo->copper += chr->copper;
//      }
//         sprintf (bunl, "You drop your coins.\n\r");
//         send_to_char (bunl, chr);
//         found = TRUE;
//         chr->gold = 0;
//         chr->copper = 0;
//       }
//   }
//      for (obj = chr->carryingObjects; obj != NULL; obj = obj_next)
//   {
//     if (!obj->next_content)
//       obj_next = NULL;
//     else
//       obj_next = obj->next_content;
//     if ((arg[3] == '\0' || is_name (&arg[4], obj->pIndexData->name))
//         && can_see_obj (chr, obj)
//         && (obj->wear_loc == WEAR_NONE)
//         && can_drop_obj (chr, obj))
//       {
//         found = TRUE;
//         if (obj->pIndexData->item_type == ITEM_BOAT && obj->boat)
//      {
//        BLIST *bd;
//        bd = new BLIST; //  (sizeof (*bd));
//        bd->next = base_blist;
//        base_blist = bd;
//        bd->vnumClan = chr->inRoom->vnumClan;
//        save_boats ();
//      }

//         currentActionsAndBehavior ("$n drops $p\x1B[37;0m.", chr, obj, NULL, TO_ROOM);
//         currentActionsAndBehavior ("You drop $p\x1B[37;0m.", chr, obj, NULL, TO_CHAR);
//         obj_from (obj);
//         if (obj->pIndexData->item_type != ITEM_BOAT && (chr->inRoom->sectortyp == SECT_WATER_SWIM || chr->inRoom->sectortyp == SECT_WATER_NOSWIM))
//      {
//        currentActionsAndBehavior ("The waters cause $p to sink beneath them; lost forever.", chr, obj, NULL, TO_CHAR);
//        free_it (obj);
//      }
//         else
//      {
//      again_10:
///* Dropped item, check for triggers on object! */
//        {
//          SINGLE_TRIGGER *tr;
//          SCRIPT_INFO *s;
//          for (tr = trigger_list[TDROPPED]; tr != NULL; tr = tr->next)
//            {
//         if (obj->pIndexData->vnumClan == tr->attached_to_obj)
//           {
//             if (tr->running_info && !tr->interrupted)
//               continue;		/* Already running, interrupted, but script says not to allow interruptions. */
//             if (tr->running_info && tr->interrupted != 2)
//               {
//            end_script (tr->running_info);
//            goto again_10;
//               }
//            {
//               char tmp[STD_LENGTH];
//               sprintf(tmp, "%d",chr->inRoom->vnumClan);
//             if (tr->keywords[0] != '\0' && !one_is_in_list_two (tmp, tr->keywords))
//               continue;
//            }
//             /* ----------------- */
//             /* Start the script! */
//             /* ----------------- */
//             tr->running_info = new SCRIPT_INFO; // (sizeof (*tr->running_info));
//             s = tr->running_info;
//             bzero (s, sizeof (*s));
//             s->current = chr;
//             s->obj = obj;
//             strcpy (s->code_seg, tr->code_label);
//             s->current_line = 0;
//             s->called_by = tr;
//             s->next = info_list;
//             info_list = s;
//             execute_code (s);
//             /* ----------------- */
//           }
//            }
//        }
///* End trigger check! */
//      again_11:
///* Dropped item, check for triggers on currentRoom! */
//        {
//          SINGLE_TRIGGER *tr;
//          SCRIPT_INFO *s;
//          for (tr = trigger_list[TDROPPED]; tr != NULL; tr = tr->next)
//            {
//         if (chr->inRoom->vnumClan == tr->attached_to_room)
//           {
//             if (tr->running_info && !tr->interrupted)
//               continue;		/* Already running, interrupted, but script says not to allow interruptions. */
//             if (tr->running_info && tr->interrupted != 2)
//               {
//            end_script (tr->running_info);
//            goto again_11;
//               }
//            {
//               char tmp[STD_LENGTH];
//               sprintf(tmp, "%d",obj->pIndexData->vnumClan);
//             if (tr->keywords[0] != '\0' && !one_is_in_list_two (tmp, tr->keywords))
//               continue;
//            }
//             /* ----------------- */
//             /* Start the script! */
//             /* ----------------- */
//             tr->running_info = new SCRIPT_INFO; //  (sizeof (*tr->running_info));
//             s = tr->running_info;
//             bzero (s, sizeof (*s));
//             s->current = chr;
//             s->currentRoom = chr->inRoom;
//             s->obj = obj;
//             strcpy (s->code_seg, tr->code_label);
//             s->current_line = 0;
//             s->called_by = tr;
//             s->next = info_list;
//             info_list = s;
//             execute_code (s);
//             /* ----------------- */
//           }
//            }
//        }
///* End trigger check! */


//        obj_to_room (obj, chr->inRoom);
//      }
//       }
//   }
//      if (!found)
//   {
//     if (arg[3] == '\0')
//       currentActionsAndBehavior ("You are not carryingObjects anything.",
//       chr, NULL, arg, TO_CHAR);
//     else
//       currentActionsAndBehavior ("You are not carryingObjects $T.",
//       chr, NULL, &arg[4], TO_CHAR);
//   }
//    }
//  return;
//}

//void do_give (CharacterData  chr, string szUserArguments)
//{
//  char arg1[SML_LENGTH];
//  char arg2[SML_LENGTH];
//  char arg3[SML_LENGTH];
//  CharacterData victim;
//  SINGLE_OBJECT *obj;
//  int amount;
//  char buf[STD_LENGTH];
//  DEFINE_COMMAND ("give", do_give, POSITION_RESTING, 0, NORMAL, "This command allows you to give something to someone.")

//    BUILDERS_CAN_GIVE (no)

//    if (FIGHTING (chr) && !pow.giveWhileFighting)
//    {
//      send_to_char ("You may not give objects while chAttacking!\n\r", chr);
//      return;
//    }

//  CAN_GIVE_ITEMS_IN_ARENA (no)
//    CAN_GIVE_ITEMS_IN_BGROUND (no)

//    szUserArguments = one_argy (szUserArguments, arg1);
//  szUserArguments = one_argy (szUserArguments, arg2);
//  szUserArguments = one_argy (szUserArguments, arg3);
//  if (arg1[0] == '\0' || arg2[0] == '\0')
//    {
//      send_to_char ("Give what to whom?\n\r", chr);
//      return;
//    }

//  if ((!str_cmp (arg2, "gold"))
//      && (is_number (arg1) && atoi (arg1) > 0))
//    {
//      amount = atoi (arg1);
//      if (amount < 1)
//   return;
//      if (chr->gold < amount)
//   {
//     send_to_char ("You don't have that many \x1B[33;1mgold\x1B[37;0m coins.\n\r", chr);
//     return;
//   }
//      if ((victim = get_char_room (chr, arg3)) == NULL)
//   {
//     send_to_char ("You don't see them here.\n\r", chr);
//     return;
//   }
//      if (victim == chr)
//   return;
//      chr->gold -= amount;
//      victim->gold += amount;
//      sprintf (buf, "You give %d \x1B[33;1mgold\x1B[37;0m coins to %s.\n\r",
//          amount, NAME (victim));
//      send_to_char (buf, chr);
//      currentActionsAndBehavior ("$n gives some \x1B[33;1mgold\x1B[37;0m to $N.", chr, NULL, victim, TO_NOTVICT);
//      sprintf (buf, "%s gives you %d \x1B[33;1mgold\x1B[37;0m coins.\n\r", NAME (chr), amount);
//      send_to_char (buf, victim);
///*     if ( IS_MOB(victim) && victim->npcdata->hire == chr )
//   {
//   victim->npcdata->paid += (amount*100);
//   if ( victim->npcdata->wage > victim->npcdata->paid )
//   {
//   sprintf(buf, "%s You still owe me %s.", NAME(chr),
//   name_amount(victim->npcdata->wage - victim->npcdata->paid ));
//   }
//   else
//   {
//   sprintf(buf, "%s Thanks.", NAME(chr));
//   victim->clanLeader = chr;
//   victim->chMaster = chr;
//   currentActionsAndBehavior("$N joins your group.",chr,NULL,victim,TO_CHAR);
//   }
//   do_tell(victim,buf);
//   } */
//      return;
//    }

//  if ((!str_cmp (arg2, "copper"))
//      && (is_number (arg1) && atoi (arg1) > 0))
//    {
//      amount = atoi (arg1);
//      if (amount < 1)
//   return;
//      if (chr->copper < amount)
//   {
//     send_to_char ("You don't have that many \x1B[33mcopper\x1B[37;0m coins.\n\r", chr);
//     return;
//   }
//      if ((victim = get_char_room (chr, arg3)) == NULL)
//   {
//     send_to_char ("You don't see them here.\n\r", chr);
//     return;
//   }
//      if (victim == chr)
//   return;
//      chr->copper -= amount;
//      victim->copper += amount;
//      sprintf (buf, "You give %d \x1B[33mcopper\x1B[37;0m coins to %s.\n\r",
//          amount, NAME (victim));
//      send_to_char (buf, chr);
//      currentActionsAndBehavior ("$n gives some \x1B[33mcopper\x1B[37;0m to $N.", chr, NULL, victim, TO_NOTVICT);
//      sprintf (buf, "%s gives you %d \x1B[33mcopper\x1B[37;0m coins.\n\r", NAME (chr), amount);
//      send_to_char (buf, victim);
///*     if ( IS_MOB(victim) && victim->npcdata->hire == chr )
//   {
//   victim->npcdata->paid += (amount);
//   if ( victim->npcdata->wage > victim->npcdata->paid )
//   {
//   sprintf(buf, "%s You still owe me %s.", NAME(chr),
//   name_amount(victim->npcdata->wage - victim->npcdata->paid ));
//   }
//   else
//   {
//   sprintf(buf, "%s Thanks.", NAME(chr));
//   victim->clanLeader = chr;
//   victim->chMaster = chr;
//   chr->num_in_group++;
//   currentActionsAndBehavior("$N joins your group.",chr,NULL,victim,TO_CHAR);
//   }
//   do_tell(victim,buf);
//   } */
//      return;
//    }

//  if ((victim = get_char_room (chr, arg2)) == NULL)
//    {
//      send_to_char ("They aren't here.\n\r", chr);
//      return;
//    }
//  if ((obj = get_obj_inv (chr, arg1)) == NULL)
//    {
//      send_to_char ("You do not have that item.\n\r", chr);
//      return;
//    }
//  if (!NOT_WORN (obj))
//    {
//      send_to_char ("You must remove it first.\n\r", chr);
//      return;
//    }
//  if ((victim = get_char_room (chr, arg2)) == NULL)
//    {
//      send_to_char ("They aren't here.\n\r", chr);
//      return;
//    }
//  if (!can_drop_obj (chr, obj))
//    {
//      send_to_char ("You can't let go of it.\n\r", chr);
//      return;
//    }
//  if (!can_see_obj (victim, obj))
//    {
//      currentActionsAndBehavior ("$N can't see it.", chr, NULL, victim, TO_CHAR);
//      return;
//    }
//  obj_from (obj);
//  obj_to_char (obj, victim);
//  obj->wear_loc = -1;
//  if (IS_SET (obj->extra_flags, ITEM_INVENTORY))
//    obj->extra_flags ^= ITEM_INVENTORY;
//  currentActionsAndBehavior ("$n gives $p\x1B[0m to $N.", chr, obj, victim, TO_NOTVICT);
//  currentActionsAndBehavior ("$n gives you $p\x1B[0m.", chr, obj, victim, TO_VICT);
//  currentActionsAndBehavior ("You give $p\x1B[0m to $N.", chr, obj, victim, TO_CHAR);
//again_12:
///* Given item, check for triggers on mobbie! */
//  if (IS_MOB (victim))
//    {
//      SINGLE_TRIGGER *tr;
//      SCRIPT_INFO *s;
//      for (tr = trigger_list[TGIVEN]; tr != NULL; tr = tr->next)
//   {
//     if (victim->pIndexData->vnumClan == tr->attached_to_mob)
//       {
//         if (tr->running_info && !tr->interrupted)
//      continue;	/* Already running, interrupted, but script says not to allow interruptions. */
//         if (tr->running_info && tr->interrupted != 2)
//      {
//        end_script (tr->running_info);
//        goto again_12;
//      }
//        {char tmp[STD_LENGTH];
//        sprintf(tmp, "%d",obj->pIndexData->vnumClan);
//         if (tr->keywords[0] != '\0' && !one_is_in_list_two (tmp, tr->keywords))
//      continue;
//        }
//         /* ----------------- */
//         /* Start the script! */
//         /* ----------------- */
//         tr->running_info = new SCRIPT_INFO; //  (sizeof (*tr->running_info));
//         s = tr->running_info;
//         bzero (s, sizeof (*s));
//         s->current = chr;
//         s->mob = victim;
//         strcpy (s->code_seg, tr->code_label);
//         s->current_line = 0;
//         s->called_by = tr;
//         s->next = info_list;
//         info_list = s;
//         execute_code (s);
//         /* ----------------- */
//       }
//   }
//    }
///* End trigger check! */
//again_13:
///* Given item, check for triggers on object! */
///*  if (IS_MOB (victim)) */
//    {
//      SINGLE_TRIGGER *tr;
//      SCRIPT_INFO *s;
//      for (tr = trigger_list[TGIVEN]; tr != NULL; tr = tr->next)
//   {
//     if (obj->pIndexData->vnumClan == tr->attached_to_obj)
//       {
//         if (tr->running_info && !tr->interrupted)
//      continue;	/* Already running, interrupted, but script says not to allow interruptions. */
//         if (tr->running_info && tr->interrupted != 2)
//      {
//        end_script (tr->running_info);
//        goto again_13;
//      }
//        {char tmp[STD_LENGTH];
//        sprintf(tmp, "%d",victim->pIndexData->vnumClan);
//         if (tr->keywords[0] != '\0' && !one_is_in_list_two (tmp , tr->keywords))
//      continue;
//        }
//         /* ----------------- */
//         /* Start the script! */
//         /* ----------------- */
//         tr->running_info = new SCRIPT_INFO; //  (sizeof (*tr->running_info));
//         s = tr->running_info;
//         bzero (s, sizeof (*s));
//         s->current = chr;
//         s->obj = obj;
//         s->mob = victim;
//         strcpy (s->code_seg, tr->code_label);
//         s->current_line = 0;
//         s->called_by = tr;
//         s->next = info_list;
//         info_list = s;
//         execute_code (s);
//         /* ----------------- */
//       }
//   }
//    }
///* End trigger check! */




//  if (IS_MOB (victim))
//    check_given_script (victim, chr, obj->pIndexData->vnumClan);
//  if (IS_MOB (victim)) {
//     char tmp[STD_LENGTH];
//     sprintf(tmp, "%d",obj->pIndexData->vnumClan);
//    hardcode_give_scripts (chr, victim,tmp);
//  }

//  return;
//}

//void do_fill (CharacterData  chr, string szUserArguments)
//{
//  char arg[SML_LENGTH];
//  SINGLE_OBJECT *obj;
//  SINGLE_OBJECT *fountain;
//  I_DRINK *dr;
//  bool found;
//  DEFINE_COMMAND ("fill", do_fill, POSITION_STANDING, 0, NORMAL, "This command allows you to fill a container or lamp.")

//    szUserArguments = one_argy (szUserArguments, arg);
//  if (arg[0] == '\0')
//    {
//      send_to_char ("Fill what?\n\r", chr);
//      return;
//    }
///*held */
//  if ((obj = get_obj_inv (chr, arg)) == NULL)
//    {
//      send_to_char ("You do not have that item.\n\r", chr);
//      return;
//    }
//  if (obj->pIndexData->item_type == ITEM_DRINK_CON)
//    {
//      found = FALSE;
//      dr = (I_DRINK *) obj->MoreRoomInfo;
//      for (fountain = chr->inRoom->MoreRoomInfo->contents; fountain != NULL;
//      fountain = fountain->next_content)
//   {
//     if (fountain->pIndexData->item_type == ITEM_FOUNTAIN)
//       {
//         found = TRUE;
//         break;
//       }
//   }
//      if (!found)
//   {
//     send_to_char ("There is no fountain here!\n\r", chr);
//     return;
//   }
//      if (dr->liquid_now != 0 && dr->liquid_type != 0)
//   {
//     send_to_char ("It already has some other liquid in it.\n\r", chr);
//     return;
//   }
//      if (dr->liquid_now >= dr->max_liquid)
//   {
//     send_to_char ("The container is full.\n\r", chr);
//     return;
//   }
//      currentActionsAndBehavior ("You fill $p\x1B[0m.", chr, obj, NULL, TO_CHAR);
//      dr->liquid_type = 0;
//      dr->liquid_now = dr->max_liquid;
//    }
//  else if (obj->pIndexData->item_type == ITEM_LIGHT)
//    {
//      SINGLE_OBJECT *obj2;
//      I_LIGHT *lg = (I_LIGHT *) obj->MoreRoomInfo;
//      I_DRINK *dr;
//      /*get_item_hold */
//      if ((obj2 = get_item_held (chr, ITEM_DRINK_CON)) == NULL)
//   {
//     send_to_char ("You don't have anything in your hand to fill it with.\n\r", chr);
//     return;
//   }
//      dr = (I_DRINK *) obj2->MoreRoomInfo;
//      if (!IS_SET (lg->light_lit, LIGHT_FILLABLE) && !IS_SET (lg->light_fillable, LIGHT_FILLABLE))
//   {
//     send_to_char ("It can't be refueled.\n\r", chr);
//     return;
//   }
//      if (dr->liquid_type != -1)
//   {
//     send_to_char ("There's no oil in that container.\n\r", chr);
//     return;
//   }
//      if (lg->light_now != 0)
//   {
//     send_to_char ("There is already some oil in it.\n\r", chr);
//     return;
//   }

//      CAN_FILL_LIGHT_WHILE_LIT (yes);

//      if (dr->liquid_now < 1)
//   {
//     send_to_char ("There is no liquid left to fill it with.\n\r", chr);
//     return;
//   }
//      if (dr->liquid_now >= lg->max_light)
//   {
//     currentActionsAndBehavior ("You fill $p\x1B[0m with $P\x1B[0m.", chr, obj, obj2, TO_CHAR);
//     lg->light_now = lg->max_light;
//     dr->liquid_now += -(lg->max_light);
//   }
//      else
//   {
//     currentActionsAndBehavior ("You empty $P\x1B[0m into $p\x1B[0m.", chr, obj, obj2, TO_CHAR);
//     lg->light_now = lg->max_light;
//     dr->liquid_now = 0;
//   }
//    }
//  else
//    {
//      send_to_char ("You can't fill that.\n\r", chr);
//      return;
//    }
//  return;
//}

//void do_empty (CharacterData  chr, string szUserArguments)
//{
//  char arg[SML_LENGTH];
//  SINGLE_OBJECT *obj;
//  DEFINE_COMMAND ("empty", do_empty, POSITION_RESTING, 0, NORMAL, "This command allows you to empty a container of liquid.")

//    szUserArguments = one_argy (szUserArguments, arg);
//  if (arg[0] == '\0')
//    {
//      send_to_char ("Empty what?\n\r", chr);
//      return;
//    }
///*held */
//  if ((obj = get_obj_inv (chr, arg)) == NULL)
//    {
//      send_to_char ("You do not have that item.\n\r", chr);
//      return;
//    }
//  if (obj->pIndexData->item_type == ITEM_DRINK_CON)
//    {
//      I_DRINK *dr = (I_DRINK *) obj->MoreRoomInfo;
//      if (dr->liquid_now < 1)
//   {
//     send_to_char ("Your container is empty.\n\r", chr);
//     return;
//   }
//      currentActionsAndBehavior ("You empty $p\x1B[0m.", chr, obj, NULL, TO_CHAR);
//      dr->liquid_type = 0;
//      dr->liquid_now = 0;
//    }
//  return;
//}

//void do_drink (CharacterData  chr, string szUserArguments)
//{
//  char arg[SML_LENGTH];
//  SINGLE_OBJECT *obj;
//  int amount;
//  bool thirsty;
//  int liquid;
//  DEFINE_COMMAND ("drink", do_drink, POSITION_RESTING, 0, NORMAL, "This command allows you to drink from something.")

//    while (szUserArguments != "" && szUserArguments[0] != '\0')
//    szUserArguments = one_argy (szUserArguments, arg);

//  if (arg[0] == '\0')
//    {
//      for (obj = chr->inRoom->MoreRoomInfo->contents; obj; obj = obj->next_content)
//   {
//     if (obj->pIndexData->item_type == ITEM_FOUNTAIN)
//       break;
//   }
//      if (obj == NULL)
//   {
//     send_to_char ("Drink what?\n\r", chr);
//     return;
//   }
//    }
//  else
//    {
//      if ((obj = get_obj_here (chr, arg, SEARCH_ROOM_FIRST)) == NULL)
//   {
//     send_to_char ("You can't find it.\n\r", chr);
//     return;
//   }
//    }
//  if (IS_PLAYER (chr) && chr->pcdata->condition[COND_DRUNK] > 10)
//    {
//      send_to_char ("You are too drunk, dazed, and confused to drink any MoreRoomInfo.\n\r", chr);
//      return;
//    }
//  if (IS_PLAYER (chr) && chr->pcdata->condition[COND_THIRST] < 7)
//    thirsty = TRUE;
//  else
//    thirsty = FALSE;
//  if (IS_PLAYER (chr) && !NO_THIRST (chr) && chr->pcdata->condition[COND_THIRST] > 40)
//    {
//      send_to_char ("If you drank any MoreRoomInfo, your bladder would explode.\n\r", chr);
//      return;
//    }
//  switch (obj->pIndexData->item_type)
//    {
//    default:
//      send_to_char ("You can't drink from that.\n\r", chr);
//      break;
//    case ITEM_FOUNTAIN:
//      {
//   I_FOUNTAIN *fn = (I_FOUNTAIN *) obj->MoreRoomInfo;
//   if (IS_PLAYER (chr))
//     chr->pcdata->condition[COND_THIRST] = 48;
//   currentActionsAndBehavior ("$n drinks from $p\x1B[0m.", chr, obj, NULL, TO_ROOM);
//   currentActionsAndBehavior ("You drink from $p\x1B[0m.", chr, obj, NULL, TO_CHAR);
//   if (fn->spells[0] > 0)
//     obj_cast_spell (fn->spells[0], fn->liquid, chr, chr, NULL);
//   if (fn->spells[1] > 0)
//     obj_cast_spell (fn->spells[1], fn->liquid, chr, chr, NULL);
//   if (fn->spells[2] > 0)
//     obj_cast_spell (fn->spells[2], fn->liquid, chr, chr, NULL);
//   break;
//      }
//    case ITEM_DRINK_CON:
//      {
//   I_DRINK *dr = (I_DRINK *) obj->MoreRoomInfo;
//   if (dr->liquid_now <= 0)
//     {
//       send_to_char ("It is empty.\n\r", chr);
//       return;
//     }
//   if ((liquid = dr->liquid_type) >= LIQ_MAX)
//     {
//       bug ("Bad liquid number %d.", liquid);
//       liquid = dr->liquid_type = 0;
//     }
//   if (liquid == -1)
//     {
//       currentActionsAndBehavior ("$n drinks lamp oil from $p\x1B[0m, and grimaces in pain.",
//       chr, obj, NULL, TO_ROOM);
//       currentActionsAndBehavior ("You drink oil from $p\x1B[0m.  Ugh!",
//       chr, obj, NULL, TO_CHAR);
//       amount = 0;
//     }
//   else
//     {
//       currentActionsAndBehavior ("$n drinks $T\x1B[0m from $p\x1B[0m.",
//       chr, obj, liq_table[liquid].liq_name, TO_ROOM);
//       currentActionsAndBehavior ("You drink $T\x1B[0m from $p\x1B[0m.",
//       chr, obj, liq_table[liquid].liq_name, TO_CHAR);
//       amount = number_range (3, 10);
//       amount = UMIN (amount, dr->liquid_now);
//       gain_condition (chr, COND_DRUNK,
//          amount * liq_table[liquid].liq_affect[COND_DRUNK]);
//       gain_condition (chr, COND_FULL,
//           amount * liq_table[liquid].liq_affect[COND_FULL]);
//       gain_condition (chr, COND_THIRST,
//         amount * liq_table[liquid].liq_affect[COND_THIRST]);
//       if (IS_PLAYER (chr) && chr->pcdata->condition[COND_DRUNK] > 10)
//         send_to_char ("You feel drunk.\n\r", chr);
//       if (IS_PLAYER (chr) && chr->pcdata->condition[COND_FULL] > 40)
//         send_to_char ("You are full.\n\r", chr);
//       if (IS_PLAYER (chr) && chr->pcdata->condition[COND_THIRST] > 40)
//         send_to_char ("You are no longer thirsty.\n\r", chr);
//       if (dr->not_poison != 0)
//         {
//      AFFECT_DATA af;
//      bzero (&af, sizeof (af));
//      currentActionsAndBehavior ("$n's face pales.", chr, NULL, NULL, TO_ROOM);
//      send_to_char ("Your intestines feel like they are on fire!\n\r", chr);
//      af.type = gsn_poison;
//      af.duration = 3 * amount;
//      af.location = NONE;
//      af.modifier = 0;
//      af.efftypeflags = AFF_POISON;
//      affect_join (chr, &af);
//         }
//     }
//   dr->liquid_now -= amount;
//   if (dr->liquid_now <= 0)
//     {
//       dr->not_poison = 0;
//       dr->liquid_type = 0;
//     }
//   break;
//      }
//    }
//#ifdef OLD_NOMOVE
//  if (IS_PLAYER (chr) && IS_SET (chr->act2, PLR_BLANKPROMPT) &&
//      chr->pcdata->condition[COND_THIRST] > 6 && thirsty)
//    {
//      if (chr->pcdata->condition[COND_FULL] > 6)
//   {
//     upd_hunger (chr);
//     upd_thirst (chr);
//   }
//      else
//   upd_thirst (chr);
//    }
//#endif
//  return;
//}

//void do_eat (CharacterData  chr, string szUserArguments)
//{
//  char arg[SML_LENGTH];
//  SINGLE_OBJECT *obj;
//  DEFINE_COMMAND ("eat", do_eat, POSITION_RESTING, 0, NORMAL, "This command allows you to eat something.")

//    szUserArguments = one_argy (szUserArguments, arg);

//  if (!str_cmp (arg, "the") || !str_cmp (arg, "some"))
//    szUserArguments = one_argy (szUserArguments, arg);

//  if (arg[0] == '\0')
//    {
//      send_to_char ("Eat what?\n\r", chr);
//      return;
//    }
//  if ((obj = get_obj_inv (chr, arg)) == NULL)
//    {
//      send_to_char ("You do not have that item.\n\r", chr);
//      return;
//    }
//  if (!IS_IMMORTAL (chr))
//    {
//      if (obj->pIndexData->item_type != ITEM_FOOD && obj->pIndexData->item_type != ITEM_PILL)
//   {
//     send_to_char ("That's not edible.\n\r", chr);
//     return;
//   }
//      if (IS_PLAYER (chr) && !NO_HUNGER (chr) && chr->pcdata->condition[COND_FULL] > 40)
//   {
//     send_to_char ("You are too full to eat MoreRoomInfo.\n\r", chr);
//     return;
//   }
//    }
//  else
//    {
//      if (obj->pIndexData->item_type == ITEM_LIGHT && IS_LIT (obj))
//   --chr->inRoom->lght;
//      if (obj->wear_loc != -1)
//   remove_obj (chr, obj->wear_loc, TRUE);
//    }
//  currentActionsAndBehavior ("$n eats $p\x1B[0m.", chr, obj, NULL, TO_ROOM);
//  currentActionsAndBehavior ("You eat $p\x1B[0m.", chr, obj, NULL, TO_CHAR);
//  switch (obj->pIndexData->item_type)
//    {
//    case ITEM_FOOD:
//      {
//   I_FOOD *fd = (I_FOOD *) obj->MoreRoomInfo;
//   if (IS_PLAYER (chr))
//     {
//       int conditiona;
//       conditiona = chr->pcdata->condition[COND_FULL];
//       gain_condition (chr, COND_FULL, fd->hours);
//       if (conditiona < 4 && chr->pcdata->condition[COND_FULL] > 4)
//         send_to_char ("You feel a bit less hungry.\n\r", chr);
//       else if (chr->pcdata->condition[COND_FULL] > 40)
//         send_to_char ("You are full.\n\r", chr);
//     }
//   if (fd->not_poison != 0)
//     {
//       /* The shit was poisoned! */
//       AFFECT_DATA af;
//       bzero (&af, sizeof (af));
//       currentActionsAndBehavior ("$n's face pales, and $e clutches $s stomach.", chr, 0, 0, TO_ROOM);
//       send_to_char ("Ouch!  You feel very sick!\n\r", chr);
//       af.type = gsn_poison;
//       af.duration = fd->hours / 2;
//       af.location = NONE;
//       af.modifier = 0;
//       af.efftypeflags = AFF_POISON;
//       affect_join (chr, &af);
//     }
//   break;
//      }
//    case ITEM_PILL:
//      {
//   I_POTION *pl = (I_POTION *) obj->MoreRoomInfo;
//   if (pl->spells[0] > 0)
//     obj_cast_spell (pl->spells[0], pl->spellLevel, chr, chr, NULL);
//   if (pl->spells[1] > 0)
//     obj_cast_spell (pl->spells[1], pl->spellLevel, chr, chr, NULL);
//   if (pl->spells[2] > 0)
//     obj_cast_spell (pl->spells[2], pl->spellLevel, chr, chr, NULL);
//   break;
//      }
//    }
//  if (IS_PLAYER (chr) && obj->pIndexData->item_type == ITEM_FOOD)
//    {
//#ifdef OLD_NOMOVE
//      upd_hungert (chr);
//#endif
//    }
//  obj_from (obj);
//  free_it (obj);
//  return;
//}

//bool draw_obj (CharacterData  chr, SINGLE_OBJECT * obj)
//{
//  if (obj->wear_loc != WEAR_BELT_1
//      && obj->wear_loc != WEAR_BELT_2
//      && obj->wear_loc != WEAR_BELT_3
//      && obj->wear_loc != WEAR_BELT_4
//      && obj->wear_loc != WEAR_BELT_5)
//    return FALSE;
//  if (hand_empty (chr) == WEAR_NONE)
//    return FALSE;
//  obj->wear_loc = -1;
//  equip_char (chr, obj, hand_empty (chr));
//  currentActionsAndBehavior ("$n draws $p\x1B[0m from $s belt.", chr, obj, NULL, TO_ROOM);
//  currentActionsAndBehavior ("You draw $p\x1B[0m from your belt.", chr, obj, NULL, TO_CHAR);
//  return TRUE;
//}

//bool sheath_obj (CharacterData  chr, SINGLE_OBJECT * obj)
//{
//  if (obj == NULL)
//    return FALSE;
//  if (!IS_SET (obj->pIndexData->wear_flags, ITEM_WEAR_BELT))
//    return FALSE;
//  if (get_eq_char (chr, WEAR_WAIST) == NULL)
//    {
//      send_to_char ("You need a belt to sheath it in.\n\r", chr);
//      return TRUE;
//    }
//  if (
//       obj->wear_loc != WEAR_HOLD_1
//       && obj->wear_loc != WEAR_HOLD_2)
//    {
//      send_to_char ("You must be holding the weapon to sheath it!\n\r", chr);
//      return FALSE;
//    }
//  if (belt_empty (chr) == WEAR_NONE)
//    {
//      send_to_char ("Remove something from your belt first.\n\r", chr);
//      return TRUE;
//    }
//  unequip_char (chr, obj);
//  obj->wear_loc = belt_empty (chr);
//  currentActionsAndBehavior ("$n sheaths $p\x1B[0m in $s belt.", chr, obj, NULL, TO_ROOM);
//  currentActionsAndBehavior ("You sheath $p\x1B[0m in your belt.", chr, obj, NULL, TO_CHAR);
//  return TRUE;
//}


//bool remove_obj (CharacterData  chr, int iWear, bool fReplace)
//{
//  SINGLE_OBJECT *obj;
//  if ((obj = get_eq_char (chr, iWear)) == NULL)
//    return TRUE;
//  if (!fReplace)
//    return FALSE;
//  if (obj->wear_loc == WEAR_NONE)
//    {
//      return FALSE;
//    }
//  if (IS_SET (obj->extra_flags, ITEM_NOREMOVE) && !IS_IMMORTAL (chr))
//    {
//      currentActionsAndBehavior ("You can't remove $p\x1B[0m.", chr, obj, NULL, TO_CHAR);
//      return FALSE;
//    }
//  if (obj->wear_loc == WEAR_WAIST)
//    {
//      SINGLE_OBJECT *obj2;
//      bool fFound = FALSE;
//      int curwear;
//      for (curwear = WEAR_BELT_1; curwear <= WEAR_BELT_3; curwear++)
//   {
//     obj2 = get_eq_char (chr, curwear);
//     if (obj2 != NULL)
//       {
//         fFound = TRUE;
//         obj2->wear_loc = -1;
//       }
//   }
//      if (fFound)
//   {
//   }
//    }
//  if (unequip_char (chr, obj))
//    {
//      currentActionsAndBehavior ("$n stops using $p\x1B[0m.", chr, obj, NULL, TO_ROOM);
//      currentActionsAndBehavior ("You stop using $p\x1B[0m.", chr, obj, NULL, TO_CHAR);
//    }
//  else
//    {
//      send_to_char ("You've got your hands full.\n\r", chr);
//      return FALSE;
//    }
//  return TRUE;
//}


//void wear_obj (CharacterData  chr, SINGLE_OBJECT * obj, bool fReplace, int loc)
//{
//  SHOP_DATA *pShop;
//  pShop = NULL;
//  if (IS_MOB (chr) && (pShop = chr->pIndexData->pShop) != NULL)
//    return;
//  else
//    {
//      /*OKAY, not a shopkeeper, go ahead and wear stuff */
//      if (CAN_WEAR (obj, ITEM_WEAR_FINGER))
//   {
//     if (loc == 0 || loc == ITEM_WEAR_FINGER)
//       {
//         if (get_eq_char (chr, WEAR_FINGER_L) != NULL
//        && get_eq_char (chr, WEAR_FINGER_R) != NULL
//        && !remove_obj (chr, WEAR_FINGER_L, fReplace)
//        && !remove_obj (chr, WEAR_FINGER_R, fReplace))
//      return;
//         if (get_eq_char (chr, WEAR_FINGER_L) == NULL)
//      {
//        currentActionsAndBehavior ("$n slips $p\x1B[0m onto $s left finger.", chr, obj, NULL, TO_ROOM);
//        currentActionsAndBehavior ("You slip $p\x1B[0m onto your left finger.", chr, obj, NULL, TO_CHAR);
//        equip_char (chr, obj, WEAR_FINGER_L);
//        return;
//      }
//         if (get_eq_char (chr, WEAR_FINGER_R) == NULL)
//      {
//        currentActionsAndBehavior ("$n slips $p onto $s right finger.", chr, obj, NULL, TO_ROOM);
//        currentActionsAndBehavior ("You slip $p onto your right finger.", chr, obj, NULL, TO_CHAR);
//        equip_char (chr, obj, WEAR_FINGER_R);
//        return;
//      }
//         bug ("Wear_obj: no free finger.", 0);
//         send_to_char ("You already wear two rings.\n\r", chr);
//         return;
//       }
//   }
//      if (CAN_WEAR (obj, ITEM_WEAR_NECK))
//   {
//     if (loc == 0 || loc == ITEM_WEAR_NECK)
//       {
//         if (get_eq_char (chr, WEAR_NECK_1) != NULL
//        && get_eq_char (chr, WEAR_NECK_2) != NULL
//        && !remove_obj (chr, WEAR_NECK_1, fReplace)
//        && !remove_obj (chr, WEAR_NECK_2, fReplace))
//      return;
//         if (get_eq_char (chr, WEAR_NECK_1) == NULL)
//      {
//        currentActionsAndBehavior ("$n clasps $p\x1B[0m around $s neck.", chr, obj, NULL, TO_ROOM);
//        currentActionsAndBehavior ("You clasp $p\x1B[0m around your neck.", chr, obj, NULL, TO_CHAR);
//        equip_char (chr, obj, WEAR_NECK_1);
//        return;
//      }
//         if (get_eq_char (chr, WEAR_NECK_2) == NULL)
//      {
//        currentActionsAndBehavior ("$n clasps $p\x1B[0m around $s neck.", chr, obj, NULL, TO_ROOM);
//        currentActionsAndBehavior ("You clasp $p\x1B[0m around your neck.", chr, obj, NULL, TO_CHAR);
//        equip_char (chr, obj, WEAR_NECK_2);
//        return;
//      }
//         bug ("Wear_obj: no free neck.", 0);
//         send_to_char ("You already wear two neck items.\n\r", chr);
//         return;
//       }
//   }
//      if (CAN_WEAR (obj, ITEM_FLOATING))
//   {
//     if (loc == 0 || loc == ITEM_FLOATING)
//       {
//         if (!remove_obj (chr, WEAR_FLOATING, fReplace))
//      return;
//         currentActionsAndBehavior ("$p begins floating nearby $n's head.", chr, obj, NULL, TO_ROOM);
//         currentActionsAndBehavior ("$p begins floating nearby your head.", chr, obj, NULL, TO_CHAR);
//         equip_char (chr, obj, WEAR_FLOATING);
//         return;
//       }
//   }
//      if (CAN_WEAR (obj, ITEM_WEAR_BODY))
//   {
//     if (loc == 0 || loc == ITEM_WEAR_BODY)
//       {
//         if (!remove_obj (chr, WEAR_BODY, fReplace))
//      return;
//         currentActionsAndBehavior ("$n wears $p\x1B[0m on $s body.", chr, obj, NULL, TO_ROOM);
//         currentActionsAndBehavior ("You wear $p\x1B[0m on your body.", chr, obj, NULL, TO_CHAR);
//         equip_char (chr, obj, WEAR_BODY);
//         return;
//       }
//   }
//      if (CAN_WEAR (obj, ITEM_WEAR_HEAD))
//   {
//     if (loc == 0 || loc == ITEM_WEAR_HEAD)
//       {
//         if (!remove_obj (chr, WEAR_HEAD, fReplace))
//      return;
//         currentActionsAndBehavior ("$n dons $p\x1B[0m on $s head.", chr, obj, NULL, TO_ROOM);
//         currentActionsAndBehavior ("You don $p\x1B[0m on your head.", chr, obj, NULL, TO_CHAR);
//         equip_char (chr, obj, WEAR_HEAD);
//         return;
//       }
//   }
//      if (CAN_WEAR (obj, ITEM_WEAR_FACE))
//   {
//     if (loc == 0 || loc == ITEM_WEAR_FACE)
//       {
//         if (!remove_obj (chr, WEAR_FACE, fReplace))
//      return;
//         currentActionsAndBehavior ("$n straps $p\x1B[0m onto $s face.", chr, obj, NULL, TO_ROOM);
//         currentActionsAndBehavior ("You strap $p onto your face.", chr, obj, NULL, TO_CHAR);
//         equip_char (chr, obj, WEAR_FACE);
//         return;
//       }
//   }
//      if (CAN_WEAR (obj, ITEM_WEAR_LEGS))
//   {
//     if (loc == 0 || loc == ITEM_WEAR_LEGS)
//       {
//         if (!remove_obj (chr, WEAR_LEGS, fReplace))
//      return;
//         currentActionsAndBehavior ("$n wears $p\x1B[0m on $s legs.", chr, obj, NULL, TO_ROOM);
//         currentActionsAndBehavior ("You wear $p\x1B[0m on your legs.", chr, obj, NULL, TO_CHAR);
//         equip_char (chr, obj, WEAR_LEGS);
//         return;
//       }
//   }
//      if (CAN_WEAR (obj, ITEM_WEAR_FEET))
//   {
//     if (loc == 0 || loc == ITEM_WEAR_FEET)
//       {
//         if (!remove_obj (chr, WEAR_FEET, fReplace))
//      return;
//         currentActionsAndBehavior ("$n slips $s feet into $p\x1B[0m.", chr, obj, NULL, TO_ROOM);
//         currentActionsAndBehavior ("You slip your feet into $p\x1B[0m.", chr, obj, NULL, TO_CHAR);
//         equip_char (chr, obj, WEAR_FEET);
//         return;
//       }
//   }
//      if (CAN_WEAR (obj, ITEM_WEAR_HANDS))
//   {
//     if (loc == 0 || loc == ITEM_WEAR_HANDS)
//       {
//         if (!remove_obj (chr, WEAR_HANDS, fReplace))
//      return;
//         currentActionsAndBehavior ("$n wears $p\x1B[0m on $s hands.", chr, obj, NULL, TO_ROOM);
//         currentActionsAndBehavior ("You wear $p\x1B[0m on your hands.", chr, obj, NULL, TO_CHAR);
//         equip_char (chr, obj, WEAR_HANDS);
//         return;
//       }
//   }
//      if (CAN_WEAR (obj, ITEM_WEAR_ARMS))
//   {
//     if (loc == 0 || loc == ITEM_WEAR_ARMS)
//       {
//         if (!remove_obj (chr, WEAR_ARMS, fReplace))
//      return;
//         currentActionsAndBehavior ("$n wears $p\x1B[0m on $s arms.", chr, obj, NULL, TO_ROOM);
//         currentActionsAndBehavior ("You wear $p\x1B[0m on your arms.", chr, obj, NULL, TO_CHAR);
//         equip_char (chr, obj, WEAR_ARMS);
//         return;
//       }
//   }
//      if (CAN_WEAR (obj, ITEM_WEAR_ABOUT))
//   {
//     if (loc == 0 || loc == ITEM_WEAR_ABOUT)
//       {
//         if (!remove_obj (chr, WEAR_ABOUT, fReplace))
//      return;
//         currentActionsAndBehavior ("$n wears $p\x1B[0m about $s body.", chr, obj, NULL, TO_ROOM);
//         currentActionsAndBehavior ("You wear $p\x1B[0m about your body.", chr, obj, NULL, TO_CHAR);
//         equip_char (chr, obj, WEAR_ABOUT);
//         return;
//       }
//   }
//      if (CAN_WEAR (obj, ITEM_WEAR_WAIST))
//   {
//     if (loc == 0 || loc == ITEM_WEAR_WAIST)
//       {
//         if (!remove_obj (chr, WEAR_WAIST, fReplace))
//      return;
//         currentActionsAndBehavior ("$n fastens $p\x1B[0m around $s waist.", chr, obj, NULL, TO_ROOM);
//         currentActionsAndBehavior ("You fasten $p\x1B[0m around your waist.", chr, obj, NULL, TO_CHAR);
//         equip_char (chr, obj, WEAR_WAIST);
//         return;
//       }
//   }
//      if (CAN_WEAR (obj, ITEM_WEAR_EAR1))
//   {
//     if (loc == 0 || loc == ITEM_WEAR_EAR1)
//       {
//         if ((get_eq_char (chr, WEAR_EAR_1) != NULL) && (get_eq_char (chr, WEAR_EAR_2) != NULL))
//      return;
//         if (get_eq_char (chr, WEAR_EAR_1) == NULL)
//      {
//        currentActionsAndBehavior ("$n wears $p\x1B[0m in $s right ear.", chr, obj, NULL, TO_ROOM);
//        currentActionsAndBehavior ("You wear $p\x1B[0m in your right ear.", chr, obj, NULL, TO_CHAR);
//        equip_char (chr, obj, WEAR_EAR_1);
//        return;
//      }
//         if (get_eq_char (chr, WEAR_EAR_2) == NULL)
//      {
//        currentActionsAndBehavior ("$n wears $p\x1B[0m in $s left ear.", chr, obj, NULL, TO_ROOM);
//        currentActionsAndBehavior ("You wear $p\x1B[0m in your left ear.", chr, obj, NULL, TO_CHAR);
//        equip_char (chr, obj, WEAR_EAR_2);
//        return;
//      }
//       }
//   }
//      if (CAN_WEAR (obj, ITEM_WEAR_ANKLE))
//   {
//     if (loc == 0 || loc == ITEM_WEAR_ANKLE)
//       {
//         if ((get_eq_char (chr, WEAR_ANKLE_1) != NULL) && (get_eq_char (chr, WEAR_ANKLE_2) != NULL))
//      return;
//         if (get_eq_char (chr, WEAR_ANKLE_1) == NULL)
//      {
//        currentActionsAndBehavior ("$n wears $p\x1B[0m around $s right ankle.", chr, obj, NULL, TO_ROOM);
//        currentActionsAndBehavior ("You wear $p\x1B[0m around your right ankle.", chr, obj, NULL, TO_CHAR);
//        equip_char (chr, obj, WEAR_ANKLE_1);
//        return;
//      }
//         if (get_eq_char (chr, WEAR_ANKLE_2) == NULL)
//      {
//        currentActionsAndBehavior ("$n wears $p\x1B[0m around $s left ankle.", chr, obj, NULL, TO_ROOM);
//        currentActionsAndBehavior ("You wear $p\x1B[0m around your left ankle.", chr, obj, NULL, TO_CHAR);
//        equip_char (chr, obj, WEAR_ANKLE_2);
//        return;
//      }
//       }
//   }
//      if (CAN_WEAR (obj, ITEM_WEAR_WRIST))
//   {
//     if (loc == 0 || loc == ITEM_WEAR_WRIST)
//       {
//         if (get_eq_char (chr, WEAR_WRIST_L) != NULL
//        && get_eq_char (chr, WEAR_WRIST_R) != NULL
//        && !remove_obj (chr, WEAR_WRIST_L, fReplace)
//        && !remove_obj (chr, WEAR_WRIST_R, fReplace))
//      return;
//         if (get_eq_char (chr, WEAR_WRIST_L) == NULL)
//      {
//        currentActionsAndBehavior ("$n wears $p\x1B[0m around $s left wrist.",
//             chr, obj, NULL, TO_ROOM);
//        currentActionsAndBehavior ("You wear $p\x1B[0m around your left wrist.",
//             chr, obj, NULL, TO_CHAR);
//        equip_char (chr, obj, WEAR_WRIST_L);
//        return;
//      }
//         if (get_eq_char (chr, WEAR_WRIST_R) == NULL)
//      {
//        currentActionsAndBehavior ("$n wears $p\x1B[0m around $s right wrist.",
//             chr, obj, NULL, TO_ROOM);
//        currentActionsAndBehavior ("You wear $p\x1B[0m around your right wrist.",
//             chr, obj, NULL, TO_CHAR);
//        equip_char (chr, obj, WEAR_WRIST_R);
//        return;
//      }
//         bug ("Wear_obj: no free wrist.", 0);
//         send_to_char ("You already wear two wrist items.\n\r", chr);
//         return;
//       }
//   }
//      if (CAN_WEAR (obj, ITEM_WEAR_SHOULDER))
//   {
//     if (loc == 0 || loc == ITEM_WEAR_SHOULDER)
//       {
//         if (get_eq_char (chr, WEAR_SHOULDER_L) != NULL
//        && get_eq_char (chr, WEAR_SHOULDER_R) != NULL
//        && !remove_obj (chr, WEAR_SHOULDER_L, fReplace)
//        && !remove_obj (chr, WEAR_SHOULDER_R, fReplace))
//      return;
//         if (get_eq_char (chr, WEAR_SHOULDER_L) == NULL)
//      {
//        currentActionsAndBehavior ("$n slings $p\x1B[0m over $s left shoulder.",
//             chr, obj, NULL, TO_ROOM);
//        currentActionsAndBehavior ("You sling $p\x1B[0m over your left shoulder.",
//             chr, obj, NULL, TO_CHAR);
//        equip_char (chr, obj, WEAR_SHOULDER_L);
//        return;
//      }
//         if (get_eq_char (chr, WEAR_SHOULDER_R) == NULL)
//      {
//        currentActionsAndBehavior ("$n slings $p\x1B[0m over $s right shoulder.",
//             chr, obj, NULL, TO_ROOM);
//        currentActionsAndBehavior ("You sling $p\x1B[0m over your right shoulder.",
//             chr, obj, NULL, TO_CHAR);
//        equip_char (chr, obj, WEAR_SHOULDER_R);
//        return;
//      }
//         bug ("Wear_obj: no free shoulder.", 0);
//         send_to_char ("You already wear two items on your shoulders.\n\r", chr);
//         return;
//       }
//   }
//      if (CAN_WEAR (obj, ITEM_WEAR_SHIELD))
//   {
//     SINGLE_OBJECT *obj1;
//     SINGLE_OBJECT *obj2;
//     if (!remove_obj (chr, WEAR_SHIELD, fReplace))
//       return;
//     obj1 = get_eq_char (chr, WEAR_HOLD_1);
//     obj2 = get_eq_char (chr, WEAR_HOLD_2);
//     if (obj->pIndexData->item_type == ITEM_ARMOR && (obj1 != NULL && obj1->pIndexData->item_type == ITEM_WEAPON) &&
//         (obj2 != NULL && obj2->pIndexData->item_type == ITEM_WEAPON))
//       {
//         send_to_char ("You can't use a shield while wielding two weapons!\n\r", chr);
//         return;
//       }
//     currentActionsAndBehavior ("$n straps $p\x1B[0m to $s arm.", chr, obj, NULL, TO_ROOM);
//     currentActionsAndBehavior ("You strap $p\x1B[0m to your arm.", chr, obj, NULL, TO_CHAR);
//     equip_char (chr, obj, WEAR_SHIELD);
//     return;
//   }

//      if ((CAN_WEAR (obj, ITEM_HOLD) || CAN_WEAR (obj, ITEM_WIELD))
//      /*&& hand_empty( chr ) != WEAR_NONE */ )
//   {
//     SINGLE_OBJECT *obj1;
//     SINGLE_OBJECT *obj2;
//     SINGLE_OBJECT *obj3;
//     if (hand_empty (chr) == WEAR_NONE)
//       {
//         currentActionsAndBehavior ("Your hands are full! Remove something first.", chr, NULL, NULL, TO_CHAR);
//         return;
//       }
//     obj1 = get_eq_char (chr, WEAR_HOLD_1);
//     obj2 = get_eq_char (chr, WEAR_HOLD_2);
//     obj3 = get_eq_char (chr, WEAR_SHIELD);
//     if (obj3 && obj->pIndexData->item_type == ITEM_WEAPON &&
//       ((obj1 != NULL && obj1->pIndexData->item_type == ITEM_WEAPON) ||
//        (obj2 != NULL && obj2->pIndexData->item_type == ITEM_WEAPON)))
//       {
//         send_to_char ("You can't wield two weapons while using a shield!\n\r", chr);
//         return;
//       }
//     if (IS_PLAYER (chr) && (obj->pIndexData->weight > ((get_curr_str (chr) * 2) / 3)))
//       {
//         currentActionsAndBehavior ("Unfortunately, $p is too heavy for you to use!", chr, obj, NULL, TO_CHAR);
//         return;
//       }
//     currentActionsAndBehavior ("$n holds $p\x1B[0m in $s hand.", chr, obj, NULL, TO_ROOM);
//     currentActionsAndBehavior ("You hold $p\x1B[0m in your hand.", chr, obj, NULL, TO_CHAR);
//     equip_char (chr, obj, hand_empty (chr));
//     return;
//   }
//      if (fReplace)
//   send_to_char ("You can't wear, wield, or hold that there.\n\r", chr);
//      return;
//      /*REMOVE this next 
//         }
//         if you remove the check for shopkeeper thingy */
//    }

//  return;
//}

//void do_swap (CharacterData  chr, string szUserArguments)
//{
//  DEFINE_COMMAND ("swap", do_exchange, POSITION_RESTING, 0, NORMAL, "This command exchanges what you have in your primary and secondary hand.")
//    return;
//}

//void do_exchange (CharacterData  chr, string szUserArguments)
//{
//  SINGLE_OBJECT *objh1;
//  SINGLE_OBJECT *objh2;
//  bool hone;
//  bool htwo;
//  DEFINE_COMMAND ("exchange", do_exchange, POSITION_FIGHTING, 0, NORMAL, "This command exchanges what you have in your primary and secondary hand.")

//    hone = FALSE;
//  htwo = FALSE;
//  if ((objh1 = get_eq_char (chr, WEAR_HOLD_1)) != NULL)
//    hone = TRUE;
//  if ((objh2 = get_eq_char (chr, WEAR_HOLD_2)) != NULL)
//    htwo = TRUE;
//  if ((!hone) && (!htwo))
//    {
//      currentActionsAndBehavior ("You aren't holding anything in your hands!", chr, NULL, NULL, TO_CHAR);
//      return;
//    }

//  if ((!hone) && (htwo))
//    {
//      objh2->wear_loc = WEAR_HOLD_1;
//      currentActionsAndBehavior ("The object in your secondary hand is now in your primary hand.", chr, NULL, NULL, TO_CHAR);
//      return;
//    }

//  if ((hone) && (!htwo))
//    {
//      objh1->wear_loc = WEAR_HOLD_2;
//      currentActionsAndBehavior ("The object in your primary hand is now in your secondary hand.", chr, NULL, NULL, TO_CHAR);
//      return;
//    }

//  if ((hone) && (htwo))
//    {
//      objh1->wear_loc = WEAR_HOLD_2;
//      objh2->wear_loc = WEAR_HOLD_1;
//      currentActionsAndBehavior ("You now hold $p\x1B[0m in your primary hand.", chr, objh2, NULL, TO_CHAR);
//      currentActionsAndBehavior ("You now hold $p\x1B[0m in your secondary hand.", chr, objh1, NULL, TO_CHAR);
//      return;
//    }

//  return;
//}

//void do_wield (CharacterData  chr, string szUserArguments)
//{
//  DEFINE_COMMAND ("wield", do_wear, POSITION_STANDING, 0, NORMAL, "Allows you to wear/wield or hold an object.")
//    return;
//}

//void do_hold (CharacterData  chr, string szUserArguments)
//{
//  DEFINE_COMMAND ("hold", do_wear, POSITION_STANDING, 0, NORMAL, "Allows you to wear/wield or hold an object.")
//    return;
//}

//void do_wear (CharacterData  chr, string szUserArguments)
//{
//  char arg1[SML_LENGTH];
//  char arg2[SML_LENGTH];
//  SINGLE_OBJECT *obj;
//  DEFINE_COMMAND ("wear", do_wear, POSITION_FIGHTING, 0, NORMAL, "Allows you to wear/wield or hold an object.")

//    szUserArguments = one_argy (szUserArguments, arg1);
//  one_argy (szUserArguments, arg2);
//  if (arg1[0] == '\0')
//    {
//      send_to_char ("Please specify what you want to wear/wield/hold.\n\r", chr);
//      return;
//    }


//  if (!str_cmp (arg1, "all"))
//    {
//      SINGLE_OBJECT *obj_next;
//      if (FIGHTING (chr) != NULL && !pow.equipInCombat)
//   {
//     send_to_char ("Not while you're chAttacking; you'd get creamed!\n\r", chr);
//     return;
//   }
//      for (obj = chr->carryingObjects; obj != NULL; obj = obj_next)
//   {
//     obj_next = obj->next_content;
//     if ((CAN_WEAR (obj, ITEM_HOLD)))
//       if (hand_empty (chr) == WEAR_NONE)
//         continue;
//     if ((obj->wear_loc == -1 || obj->wear_loc == WEAR_NONE	/*|| 
//                              obj->wear_loc == WEAR_HOLD_1 ||
//                              obj->wear_loc == WEAR_HOLD_2 */ ) && can_see_obj (chr, obj))
//       wear_obj (chr, obj, FALSE, 0);
//   }
//      return;
//    }
//  else
//    {
///*held */
//      if ((obj = get_obj_inv (chr, arg1)) == NULL)
//   {
//     send_to_char ("You do not have that item.\n\r", chr);
//     return;
//   }

//      if ((CAN_WEAR (obj, ITEM_HOLD)))
//   if (hand_empty (chr) == WEAR_NONE)
//     {
//       send_to_char ("Your hands are already full!\n\r", chr);
//       return;
//     }

//      if (FIGHTING (chr) != NULL && !pow.equipInCombat && !CAN_WEAR (obj, ITEM_HOLD))
//   {
//     send_to_char ("Not while you're chAttacking; you'd get creamed!\n\r", chr);
//     return;
//   }

//      if (obj->wear_loc == -1)
//   {
//     wear_obj (chr, obj, TRUE, wear_name_bit (arg2));
//   }
//    }

//  return;
//}
//void do_sheath (CharacterData  chr, string szUserArguments)
//{
//  char arg1[STD_LENGTH];
//  SINGLE_OBJECT *obj;
//  DEFINE_COMMAND ("sheath", do_sheath, POSITION_STANDING, 0, NORMAL, "Allows you to sheath a weapon in your belt.")

//    szUserArguments = one_argy (szUserArguments, arg1);
///*get_obj_held */
//  if ((obj = get_obj_inv (chr, arg1)) == NULL)
//    {
///*item_held */
//      if (get_item_held (chr, ITEM_WEAPON) != NULL)
//   sheath_obj (chr, get_item_held (chr, ITEM_WEAPON));
//      if (get_item_held (chr, ITEM_WEAPON) != NULL)
//   sheath_obj (chr, get_item_held (chr, ITEM_WEAPON));
//      return;
//    }

//  if (!sheath_obj (chr, obj))
//    send_to_char ("You can't do that!\n\r", chr);
//  return;
//}
//void do_draw (CharacterData  chr, string szUserArguments)
//{
//  char arg1[STD_LENGTH];
//  SINGLE_OBJECT *obj;
//  DEFINE_COMMAND ("draw", do_draw, POSITION_FIGHTING, 0, NORMAL, "Allows you to draw a weapon from your belt.")

//    if (get_item_held (chr, ITEM_WEAPON) != NULL && get_obj_wear (chr, "shield") != NULL)
//    {
//      send_to_char ("You may not use two weapons with a shield.\n\r", chr);
//      return;
//    }

//  szUserArguments = one_argy (szUserArguments, arg1);
//  if ((obj = get_obj_wear (chr, arg1)) == NULL)
//    {
//      send_to_char ("You do not have that item in your belt.\n\r", chr);
//      return;
//    }

//  if (!draw_obj (chr, obj))
//    send_to_char ("You can't do that!\n\r", chr);
//  return;
//}

//void do_remove (CharacterData  chr, string szUserArguments)
//{
//  char arg[SML_LENGTH];
//  SINGLE_OBJECT *obj;
//  DEFINE_COMMAND ("remove", do_remove, POSITION_FIGHTING, 0, NORMAL, "This command allows you to remove a weapon/naturalArmor/etc... that is worn.")

//    one_argy (szUserArguments, arg);
//  if (arg[0] == '\0')
//    {
//      send_to_char ("Remove what?\n\r", chr);
//      return;
//    }

//  if (!str_cmp (szUserArguments, "all"))
//    {
//      SINGLE_OBJECT *obj_next;
//      if (!pow.removeWhileFighting && FIGHTING (chr))
//   {
//     send_to_char ("No way; you'd get creamed!\n\r", chr);
//     return;
//   }
//      for (obj = chr->carryingObjects; obj != NULL; obj = obj_next)
//   {
//     obj_next = obj->next_content;
//     /* if ( (obj->wear_loc == -1 || obj->wear_loc == WEAR_NONE || 
//        obj->wear_loc == WEAR_HOLD_1 ||
//        obj->wear_loc == WEAR_HOLD_2) && can_see_obj( chr, obj ) )
//        wear_obj( chr, obj, FALSE, 0 ); */
//     if (obj->wear_loc != WEAR_NONE && obj->wear_loc != -1)
//       remove_obj (chr, obj->wear_loc, TRUE);
//   }
//      if (chr->MPCurrent > chr->MPMax)
//   MAXMOVE(chr);
//      return;
//    }

//  if ((obj = get_obj_wear (chr, arg)) == NULL)
//    {
//      send_to_char ("You do not have that item.\n\r", chr);
//      return;
//    }

//  if (!pow.removeWhileFighting && obj->wear_loc != WEAR_HOLD_1 &&
//      obj->wear_loc != WEAR_HOLD_2 && FIGHTING (chr))
//    {
//      send_to_char ("No way; you'd get creamed!\n\r", chr);
//      return;
//    }

//  if (obj->wear_loc != -1)
//    {
//      remove_obj (chr, obj->wear_loc, TRUE);
//    }
//  if (chr->MPCurrent > chr->MPMax)
//    MAXMOVE(chr);
//  if (chr->HPCurrent > chr->HPMax)
//    chr->HPCurrent = chr->HPMax;
//  return;
//}

//void do_bury (CharacterData  chr, string szUserArguments)
//{
//  DEFINE_COMMAND ("bury", do_sacrifice, POSITION_RESTING, 0, NORMAL, "Allows you to sacrifice something to the gods... helps clean up the game.")
//    return;
//}

//void do_sacrifice (CharacterData  chr, string szUserArguments)
//{
//  char arg[SML_LENGTH];
//  SINGLE_OBJECT *obj;
//  const string god;
//  int n_god;
//  char buf[STD_LENGTH];

//  DEFINE_COMMAND ("sacrifice", do_sacrifice, POSITION_RESTING, 0, NORMAL, "Allows you to sacrifice something to the gods... helps clean up the game.")

//    if (szUserArguments == "" || szUserArguments[0] == '\0')
//    return;
//  one_argy (szUserArguments, arg);
//  if (arg[0] == '\0' || !str_cmp (arg, NAME (chr)))
//    {
//      currentActionsAndBehavior ("$n offers $mself to the gods, who decline.",
//      chr, NULL, NULL, TO_ROOM);
//      send_to_char (
//       "The gods appreciate your self-sacrifice, but refuse.\n\r", chr);
//      return;
//    }

//  obj = get_obj_list (chr, arg, chr->inRoom->MoreRoomInfo->contents);
//  if (obj == NULL)
//    {
//      if (get_obj_inv (chr, arg) != NULL)
//   {
//     send_to_char ("The object must be lying on the ground in order to sacrifice it.\n\r", chr);
//     return;
//   }
//      send_to_char ("You don't see that object here to sacrifice.\n\r", chr);
//      return;
//    }

//  if (!CAN_WEAR (obj, ITEM_TAKE))
//    {
//      currentActionsAndBehavior ("$p\x1B[0m is not a sacrificable object.", chr, obj, 0, TO_CHAR);
//      return;
//    }

//  if (obj->pIndexData->item_type == ITEM_BOAT)
//    {
//      send_to_char ("You cannot sacrifice something that large!\n\r", chr);
//      return;
//    }

//  n_god = number_range (0, 4);
//  god = pow.godNames[n_god];
//  sprintf (buf, "$n sacrifices $p\x1B[0m to \x1B[1m%s\x1B[0m.", god);
//  currentActionsAndBehavior (buf, chr, obj, NULL, TO_ROOM);
//  sprintf (buf, "You sacrifice $p\x1B[0m to \x1B[1m%s\x1B[0m.", god);
//  currentActionsAndBehavior (buf, chr, obj, NULL, TO_CHAR);
//  if (LEVEL (chr) < 9 && obj->pIndexData->item_type == ITEM_CORPSE_NPC)
//    {
//      send_to_char ("You recieve a copper coin as a gift from the gods for this sacrifice!\n\r", chr);
//      chr->copper++;
//    }

//  if (obj->carried_by != NULL)
//    obj_from (obj);
//  free_it (obj);
//  return;
//}

//void do_quaff (CharacterData  chr, string szUserArguments)
//{
//  char arg[SML_LENGTH];
//  SINGLE_OBJECT *obj;
//  I_POTION *pt;
//  DEFINE_COMMAND ("quaff", do_quaff, POSITION_FIGHTING, 0, NORMAL, "Allows you to quaff a potion.")

//    one_argy (szUserArguments, arg);
//  if (arg[0] == '\0')
//    {
//      send_to_char ("Quaff what?\n\r", chr);
//      return;
//    }

//  if ((obj = get_obj_inv (chr, arg)) == NULL)
//    {
//      send_to_char ("You do not have that potion.\n\r", chr);
//      return;
//    }

//  if (obj->pIndexData->item_type != ITEM_POTION)
//    {
//      send_to_char ("You can quaff only potions.\n\r", chr);
//      return;
//    }
//  pt = (I_POTION *) obj->MoreRoomInfo;
//  currentActionsAndBehavior ("$n quaffs $p\x1B[0m.", chr, obj, NULL, TO_ROOM);
//  currentActionsAndBehavior ("You quaff $p\x1B[0m.", chr, obj, NULL, TO_CHAR);
//  if (pt->spells[0] > 0)
//    obj_cast_spell (pt->spells[0], pt->spellLevel, chr, chr, NULL);
//  if (pt->spells[1] > 0)
//    obj_cast_spell (pt->spells[1], pt->spellLevel, chr, chr, NULL);
//  if (pt->spells[2] > 0)
//    obj_cast_spell (pt->spells[2], pt->spellLevel, chr, chr, NULL);
//  obj_from (obj);
//  free_it (obj);
//  return;
//}

//void do_read (CharacterData  chr, string szUserArguments)
//{
//  DEFINE_COMMAND ("read", do_look, POSITION_RESTING, 0, NORMAL, "Same as look.")
//    return;
//}

//void do_recite (CharacterData  chr, string szUserArguments)
//{
//  char arg1[SML_LENGTH];
//  char arg2[SML_LENGTH];
//  CharacterData victim;
//  I_POTION *sc;
//  SINGLE_OBJECT *scroll;
//  SINGLE_OBJECT *obj;
//  DEFINE_COMMAND ("recite", do_recite, POSITION_FIGHTING, 0, NORMAL, "Allows you to recite a scroll.")

//    szUserArguments = one_argy (szUserArguments, arg1);
//  szUserArguments = one_argy (szUserArguments, arg2);
//  if ((scroll = get_obj_inv (chr, arg1)) == NULL)
//    {
//      send_to_char ("You do not have that scroll.\n\r", chr);
//      return;
//    }

//  if (scroll->pIndexData->item_type != ITEM_SCROLL)
//    {
//      send_to_char ("You can recite only scrolls.\n\r", chr);
//      return;
//    }
//  sc = (I_POTION *) scroll->MoreRoomInfo;
//  obj = NULL;
//  if (arg2[0] == '\0')
//    {
//      victim = chr;
//    }

//  else
//    {
//      if ((victim = get_char_room (chr, arg2)) == NULL
//     && (obj = get_obj_here (chr, arg2, SEARCH_INV_FIRST)) == NULL)
//   {
//     send_to_char ("You can't find it.\n\r", chr);
//     return;
//   }
//    }

//  currentActionsAndBehavior ("$n recites $p\x1B[0m.", chr, scroll, NULL, TO_ROOM);
//  currentActionsAndBehavior ("You recite $p\x1B[0m.", chr, scroll, NULL, TO_CHAR);
//  if (sc->spells[0] > 0)
//    obj_cast_spell (sc->spells[0], sc->spellLevel, chr, victim, obj);
//  if (sc->spells[1] > 0)
//    obj_cast_spell (sc->spells[1], sc->spellLevel, chr, victim, obj);
//  if (sc->spells[2] > 0)
//    obj_cast_spell (sc->spells[2], sc->spellLevel, chr, victim, obj);
//  free_it (scroll);
//  return;
//}
//void do_brandish (CharacterData  chr, string szUserArguments)
//{
//  CharacterData vch;
//  CharacterData vch_next;
//  SINGLE_OBJECT *staff;
//  SPELL_DATA *spell;
//  I_WAND *stf;
//  DEFINE_COMMAND ("brandish", do_brandish, POSITION_FIGHTING, 0, NORMAL, "Allows you to brandish a staff.")

//    if ((staff = get_item_held (chr, ITEM_STAFF)) == NULL)
//    {
//      send_to_char ("You don't have the staff in your hand.\n\r", chr);
//      return;
//    }
//  stf = (I_WAND *) staff->MoreRoomInfo;
//  if ((spell = skill_lookup (NULL, stf->spells[0])) == NULL)
//    {
//      bug ("Do_brandish: bad sn %d.", 9999);
//      return;
//    }

//  WAIT_STATE (chr, 2 * PULSE_VIOLENCE);
//  if (stf->current_charges > 0)
//    {
//      currentActionsAndBehavior ("$n raises $p\x1B[0m into the air and utters some mystical words under $s breath.",
//      chr, staff, NULL, TO_ROOM);
//      currentActionsAndBehavior ("You brandish $p\x1B[0m.", chr, staff, NULL, TO_CHAR);
//      for (vch = chr->inRoom->MoreRoomInfo->people; vch; vch = vch_next)
//   {
//     vch_next = vch->next_in_room;
//     switch (spell->spell_type)
//       {
//       default:
//         bug ("Do_brandish: bad target for sn %d.", spell->gsn);
//         return;
//       case TAR_IGNORE:
//         if (vch != chr)
//      continue;
//         break;
//       case TAR_CHAR_OFFENSIVE:
//         if (IS_MOB (chr) ? IS_MOB (vch) : IS_PLAYER (vch))
//      continue;
//         break;
//       case TAR_CHAR_DEFENSIVE:
//         if (IS_MOB (chr) ? IS_PLAYER (vch) : IS_MOB (vch))
//      continue;
//         break;
//       case TAR_CHAR_SELF:
//         if (vch != chr)
//      continue;
//         break;
//       }
//     if (stf->spells[0] > 0)
//       obj_cast_spell (stf->spells[0], stf->spellLevel, chr, vch, NULL);
//   }
//    }

//  if (--stf->current_charges <= 0)
//    {
//      currentActionsAndBehavior ("$n's $p\x1B[0m blazes bright and is gone.", chr, staff, NULL, TO_ROOM);
//      currentActionsAndBehavior ("Your $p\x1B[0m blazes bright and is gone.", chr, staff, NULL, TO_CHAR);
//      free_it (staff);
//    }

//  return;
//}
//void do_zap (CharacterData  chr, string szUserArguments)
//{
//  char arg[SML_LENGTH];
//  CharacterData victim;
//  SINGLE_OBJECT *wand;
//  SINGLE_OBJECT *obj;
//  SPELL_DATA *spell;
//  I_WAND *wnd;
//  DEFINE_COMMAND ("zap", do_zap, POSITION_FIGHTING, 0, NORMAL, "Allows you to zap a wand.")

//    one_argy (szUserArguments, arg);
//  if (arg[0] == '\0' && FIGHTING (chr) == NULL)
//    {
//      send_to_char ("Zap whom or what?\n\r", chr);
//      return;
//    }

//  if ((wand = get_item_held (chr, ITEM_WAND)) == NULL)
//    {
//      send_to_char ("You don't have a wand in your hand.\n\r", chr);
//      return;
//    }
//  wnd = (I_WAND *) wand->MoreRoomInfo;
//  if ((spell = skill_lookup (NULL, wnd->spells[0])) == NULL)
//    {
//      bug ("Do_zap: bad sn %d.", 0);
//      return;
//    }

//  obj = NULL;
//  if (arg[0] == '\0')
//    {
//      if (FIGHTING (chr) != NULL)
//   {
//     victim = FIGHTING (chr);
//   }
//      else
//   {
//     send_to_char ("Zap whom or what?\n\r", chr);
//     return;
//   }
//    }

//  else
//    {
//      if ((victim = get_char_room (chr, arg)) == NULL
//     && (obj = get_obj_here (chr, arg, SEARCH_INV_FIRST)) == NULL)
//   {
//     send_to_char ("You can't find it.\n\r", chr);
//     return;
//   }
//    }

//  WAIT_STATE (chr, 2 * PULSE_VIOLENCE);
//  if (wnd->current_charges > 0)
//    {
//      if (victim != NULL)
//   {
//     currentActionsAndBehavior ("$n zaps $N with $p\x1B[0m.", chr, wand, victim, TO_ROOM);
//     currentActionsAndBehavior ("You zap $N with $p\x1B[0m.", chr, wand, victim, TO_CHAR);
//   }
//      else
//   {
//     currentActionsAndBehavior ("$n zaps $P with $p\x1B[0m.", chr, wand, obj, TO_ROOM);
//     currentActionsAndBehavior ("You zap $P with $p\x1B[0m.", chr, wand, obj, TO_CHAR);
//   }
//      if (wnd->spells[0] > 0)
//   obj_cast_spell (wnd->spells[0], wnd->spellLevel, chr, victim, obj);
//    }

//  if (--wnd->current_charges <= 0)
//    {
//      currentActionsAndBehavior ("$n's $p\x1B[0m explodes into fragments.", chr, wand, NULL, TO_ROOM);
//      currentActionsAndBehavior ("Your $p\x1B[0m explodes into fragments.", chr, wand, NULL, TO_CHAR);
//      free_it (wand);
//    }

//  return;
//}
//void do_study (CharacterData  chr, string szUserArguments)
//{
//  SINGLE_OBJECT *obj;
//  SPELL_DATA *spell;
//  I_BOOK *bk;
//  DEFINE_COMMAND ("study", do_study, POSITION_RESTING, 0, NORMAL, "Allows you to study a book.")

//    if ((obj = get_obj_inv (chr, szUserArguments)) == NULL)
//    {
//      send_to_char ("You don't have that to study.\n\r", chr);
//      return;
//    }

//  if (obj->pIndexData->item_type != ITEM_BOOK)
//    {
//      send_to_char ("That's not a book.. wouldn't want it to BURST into FLAMES! heh.\n\r", chr);
//      return;
//    }
//  bk = (I_BOOK *) obj->MoreRoomInfo;
//  if (bk->teaches == 0)
//    {
//      send_to_char ("You begin to read... Blah blah blah...\n\rYou soon discover that there is nothing you can learn from this book.\n\r", chr);
//      return;
//    }

//  spell = skill_lookup (NULL, bk->teaches);
//  if (spell == NULL)
//    {
//      send_to_char ("Some LAME builder created this book wrong - it doesn't do SHIT!\n\rHAHAHAHAHA!", chr);
//      return;
//    }
//  if (pow.professions && !(chr->pcdata->profession_flag & spell->values[0]))
//    {
//      send_to_char ("You can't seem to understand the spell it's talking about...\n\r", chr);
//      return;
//    }
///*past this point the book FRIES.. */
//  if (chr->pcdata->learned[(bk->teaches)] > 25)
//    {
//      send_to_char ("You read the book and a knowledge and understanding begins to\n\rmeld into your open mind... Unfortunately the book doesn't seem to\n\rteach you anything you don't already know! DOH!\n\r", chr);
//    }

//  else
//    {
//      char buf[STD_LENGTH];
//      send_to_char ("You read the book and a knowledge and understanding begins to\n\rmeld into your open mind...\n\r", chr);
//      sprintf (buf, "You now understand the very basics of %s!!\n\r", spell->spell_funky_name);
//      send_to_char (buf, chr);
//      chr->pcdata->learned[(bk->teaches)] = 26;
//    }

//  currentActionsAndBehavior ("$n reads $p\x1B[0m, and it bursts into flames!", chr, obj, NULL, TO_ROOM);
//  currentActionsAndBehavior ("After you read $p\x1B[0m, it bursts into flames!", chr, obj, NULL, TO_CHAR);
//  free_it (obj);
//  return;
//}

//#ifdef ALLOW_STEAL
//void do_steal (CharacterData  chr, string szUserArguments)
//{
//  char buf[STD_LENGTH];
//  char arg1[SML_LENGTH];
//  char arg2[SML_LENGTH];
//  CharacterData victim;
//  SINGLE_OBJECT *obj;
//  int percent;
//  if (LEVEL (chr) > 100)
//    return;
//  szUserArguments = one_argy (szUserArguments, arg1);
//  szUserArguments = one_argy (szUserArguments, arg2);
//  if (arg1[0] == '\0' || arg2[0] == '\0')
//    {
//      send_to_char ("Steal what from whom?\n\r", chr);
//      return;
//    }

//  if (IS_PLAYER (chr) && (chr->in_battle || chr->challenge == 10))
//    {
//      send_to_char ("Not in the battleground or arena!\n\r", chr);
//      return;
//    }

//  if ((victim = get_char_room (chr, arg2)) == NULL)
//    {
//      send_to_char ("They aren't here.\n\r", chr);
//      return;
//    }

//  if (victim->level > 99)
//    {
//      send_to_char ("Forget it.\n\r", chr);
//      return;
//    }

//  if (victim == chr)
//    {
//      send_to_char ("Like a dull sword, that's pointless.\n\r", chr);
//      return;
//    }

//  WAIT_STATE (chr, 24);
//  percent = number_percent () + (IS_AWAKE (victim) ? 10 : -50);
//  if (is_safe (chr, victim))
//    {
//      if (IS_PLAYER (chr))
//   {
//     currentActionsAndBehavior ("\x1B[1;37mYou feel as if the gods are watching, and a hot pain spreads", chr, NULL, NULL, TO_CHAR);
//     currentActionsAndBehavior ("through your hand. OUCH! Perhaps you should not steal here...\x1B[0m", chr, NULL, NULL, TO_CHAR);
//   }
//      return;
//    }

//  else
//    {
//      if (victim->position == POSITION_FIGHTING
//     || (IS_PLAYER (chr) && number_range (0, 115) > chr->pcdata->learned[gsn_steal])
//     || (IS_MOB (chr) && (number_range (1, 10) < 4)) ||
//     (IS_MOB (victim) && victim->pIndexData->pShop != NULL))
//   {
//     send_to_char ("Oops.\n\r", chr);
//     currentActionsAndBehavior ("$n tried to steal from you.\n\r", chr, NULL, victim, TO_VICT);
//     currentActionsAndBehavior ("$n tried to steal from $N.\n\r", chr, NULL, victim, TO_NOTVICT);
//     sprintf (buf, "%s is a bloody thief!", NAME (chr));
//     send_to_char (buf, victim);
//     if (IS_PLAYER (chr))
//       {
//         if (IS_MOB (victim))
//      {
//        multi_hit (victim, chr, TYPE_UNDEFINED);
//      }
//         else
//      {
//        chr->pcdata->bounty += 10;
//        chr->alignment -= 15;
//        conv_race (chr);
//        if (!IS_EVIL (chr))
//          send_to_char ("You are well on your way to becoming a wanted criminal!\n\r", chr);
//      }
//       }
//     return;
//   }
//      else
//   {
//     if ((obj = get_obj_inv (victim, arg1)) == NULL)
//       {
//         send_to_char ("You can't find it.\n\r", chr);
//         return;
//       }
//     if (obj->wear_loc != -1)
//       {
//         send_to_char ("You can't steal things people are WEARING or HOLDING!!!\n\r", chr);
//         return;
//       }
//     if (!can_drop_obj (chr, obj)
//         || IS_SET (obj->extra_flags, ITEM_INVENTORY))
//       {
//         send_to_char ("You can't pry it away.\n\r", chr);
//         return;
//       }
//     if (number_range (1, 5) == 2)
//       {
//         currentActionsAndBehavior ("$N's suddenly looks your way, and you whistle innocently.", chr, NULL, victim, TO_CHAR);
//         return;
//       }

//     obj_from (obj);
//     obj_to (obj, chr);
//     obj->wear_loc = -1;
//     send_to_char ("Stolen.\n\r", chr);
//     skill_gain (chr, gsn_steal, FALSE);
//   }
//      return;
//    }

//  return;
//}
//#endif

//void do_light (CharacterData  chr, string szUserArguments)
//{
//  char arg[SML_LENGTH];
//  SINGLE_OBJECT *obj;
//  SINGLE_OBJECT *obj2;
//  I_LIGHT *lt;
//  I_TOOL *tb;
//  DEFINE_COMMAND ("lght", do_light, POSITION_RESTING, 0, NORMAL, "Allows you to lght a lght source.")

//    szUserArguments = one_argy (szUserArguments, arg);
//  if (arg[0] == '\0')
//    obj = get_item_held (chr, ITEM_LIGHT);
//  else
//    obj = get_obj_inv (chr, arg);
//  obj2 = get_obj_inv (chr, "tinderbox");
//  if (obj == NULL)
//    {
//      send_to_char ("You don't have the lght.\n\r", chr);
//      return;
//    }

//  if (obj->pIndexData->item_type != ITEM_LIGHT)
//    {
//      send_to_char ("You can't lght that!\n\r", chr);
//      return;
//    }
//  lt = (I_LIGHT *) obj->MoreRoomInfo;
//  if (IS_LIT (obj))
//    {
//      send_to_char ("It's lit already!\n\r", chr);
//      return;
//    }

//  if (lt->light_now <= 0)
//    {
//      send_to_char ("It's out of fuel.\n\r", chr);
//      return;
//    }

//  if (obj2 == NULL)
//    {
//      send_to_char ("You don't have anything to lght it with!\n\r", chr);
//      return;
//    }
//  tb = (I_TOOL *) obj2->MoreRoomInfo;
//  if (use_tool (obj2, TOOL_TINDERBOX))
//    {
//      SET_BIT (lt->light_lit, LIGHT_LIT);
//      currentActionsAndBehavior ("$n lights $p with $P.", chr, obj, obj2, TO_ROOM);
//      currentActionsAndBehavior ("You lght $p with $P.", chr, obj, obj2, TO_CHAR);
//      if (obj->wear_loc != -1)
//   chr->inRoom->lght++;
//      if (tb->uses == 1)
//   {
//     send_to_char ("Your tinderbox is almost out of tinder, and the flint is starting to chip.\n\r", chr);
//   }
//      if (tb->uses == 0)
//   {
//     send_to_char ("Your tinderbox is out of tinder and the flint is chipped...\n\rTime to buy a new one!\n\r", chr);
//     obj_from (obj2);
//     free_it (obj2);
//   }
//      return;
//    }

//  else
//    {
//      send_to_char ("You can't lght it with that.\n\r", chr);
//      return;
//    }

//  return;
//}
//void do_extinguish (CharacterData  chr, string szUserArguments)
//{
//  char arg[SML_LENGTH];
//  SINGLE_OBJECT *obj;
//  I_LIGHT *lt;
//  DEFINE_COMMAND ("extinguish", do_extinguish, POSITION_RESTING, 0, NORMAL, "Allows you to extinguish a lght source.")

//    szUserArguments = one_argy (szUserArguments, arg);
//  if (arg[0] == '\0')
//    obj = get_item_held (chr, ITEM_LIGHT);
///*held */
//  else
//    obj = get_obj_inv (chr, arg);
//  if (obj == NULL)
//    {
//      send_to_char ("You don't have the lght in your hands.\n\r", chr);
//      return;
//    }

//  if (obj->pIndexData->item_type != ITEM_LIGHT)
//    {
//      send_to_char ("That's not a lght source.\n\r", chr);
//      return;
//    }
//  lt = (I_LIGHT *) obj->MoreRoomInfo;
//  if (!IS_LIT (obj))
//    {
//      send_to_char ("It's extinguished already!\n\r", chr);
//      return;
//    }

//  REMOVE_BIT (lt->light_lit, LIGHT_LIT);
//  currentActionsAndBehavior ("$n extinguishes $p.", chr, obj, NULL, TO_ROOM);
//  currentActionsAndBehavior ("You extinguish $p.", chr, obj, NULL, TO_CHAR);
//  if (obj->wear_loc != -1)
//    chr->inRoom->lght--;
//  return;
//}
//void do_butcher (CharacterData  chr, string szUserArguments)		/*By Arcane */
//{
//  SINGLE_OBJECT *obj, *weap, *steak;
//  int count, x;
//  char buf[STD_LENGTH];
//  DEFINE_COMMAND ("butcher", do_butcher, POSITION_STANDING, 0, NORMAL, "Allows you to butcher a corpse into steaks.  Based on your butcher skill.")

//    if (szUserArguments[0] == '\0')
//    {
//      send_to_char ("What do you want to butcher?\n\r", chr);
//      return;
//    }

//  if ((obj = get_obj_here (chr, szUserArguments, SEARCH_ROOM_FIRST)) == NULL)
//    {
//      send_to_char ("That's not here.\n\r", chr);
//      return;
//    }

//  if (obj->pIndexData->item_type != ITEM_CORPSE_NPC)
//    {
//      send_to_char ("You can't butcher that!\n\r", chr);
//      return;
//    }

//  if ((weap = get_item_held (chr, ITEM_WEAPON)) == NULL)
//    {
//      send_to_char ("You need something to cut with!\n\r", chr);
//      return;
//    }

//  if (!IS_SET (weap->extra_flags, ITEM_PIERCE)
//      && !IS_SET (weap->extra_flags, ITEM_SLASHING)
//      && !IS_SET (weap->extra_flags, ITEM_HEAVY_SLASH)
//      && !IS_SET (weap->extra_flags, ITEM_LIGHT_SLASH))
//    {
//      send_to_char ("You need something sharp to cut with!\n\r", chr);
//      return;
//    }

//  if (number_range (0, 100) > chr->pcdata->learned[gsn_butcher])
//    {
//      send_to_char ("Your clumsy hands destroy the corpse.\n\r", chr);
//      free_it (obj);
//      return;
//    }

//  count = dice (1, 3);
//  sprintf (buf, "You slice and dice the corpse into %d steak%s.\n\r",
//      count, (count > 1 ? "s" : ""));
//  send_to_char (buf, chr);
//  for (x = 0; x < count; x++)
//    {
//      steak = create_object (get_obj_index (110), 0);
//      steak->mobSelfDestructsAt = number_range (13, 20);
//      if (dice (1, 100) == 13)
//   {
//     /*sprintf(buf, "a greenish steak");
//        free_string( steak->short_descr );
//        steak->short_descr = str_dup( buf ); */
//     ((I_FOOD *) steak->MoreRoomInfo)->not_poison = 1;
//   }
//      obj_to_room (steak, chr->inRoom);
//    }

//  skill_gain (chr, gsn_butcher, TRUE);
//  free_it (obj);
//  return;
//}

